Iterator- and range-based algorithms, like the standard algorithms.
Functions | |
template<typename I0 , typename S0 , typename I1 , typename C = equal_to, typename P0 = identity, typename P1 = identity> | |
requires input_iterator< I0 > &&sentinel_for< S0, I0 > &&input_iterator< I1 > &&indirectly_comparable< I0, I1, C, P0, P1 > | ranges::__attribute__ ((deprecated("Use the variant of ranges::equal that takes an upper bound for " "both sequences"))) const expr bool equal(I0 begin0 |
function template equal | |
template<typename Rng0 , typename I1Ref , typename C = equal_to, typename P0 = identity, typename P1 = identity> | |
requires input_range< Rng0 > &&input_iterator< uncvref_t< I1Ref > > &&indirectly_comparable< iterator_t< Rng0 >, uncvref_t< I1Ref >, C, P0, P1 > | ranges::__attribute__ ((deprecated("Use the variant of ranges::equal that takes an upper bound for " "both sequences"))) const expr bool equal(Rng0 &&rng0 |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I1 , typename S1 , typename I2 , typename C = equal_to, typename P1 = identity, typename P2 = identity> | |
requires forward_iterator< I1 > &&sentinel_for< S1, I1 > &&forward_iterator< I2 > &&indirectly_comparable< I1, I2, C, P1, P2 > | ranges::__attribute__ ((deprecated("Use the variant of ranges::is_permutation that takes an upper bound " "for both sequences"))) bool is_permutation(I1 begin1 |
function template is_permutation | |
template<typename Rng1 , typename I2Ref , typename C = equal_to, typename P1 = identity, typename P2 = identity> | |
requires forward_range< Rng1 > &&forward_iterator< uncvref_t< I2Ref > > &&indirectly_comparable< iterator_t< Rng1 >, uncvref_t< I2Ref >, C, P1, P2 > | ranges::__attribute__ ((deprecated("Use the variant of ranges::is_permutation that takes an upper bound " "for both sequences"))) bool is_permutation(Rng1 &&rng1 |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename Rng1 , typename I2Ref , typename C = equal_to, typename P1 = identity, typename P2 = identity> | |
requires input_range< Rng1 > &&input_iterator< uncvref_t< I2Ref > > &&indirect_relation< C, projected< iterator_t< Rng1 >, P1 >, projected< uncvref_t< I2Ref >, P2 > > | ranges::__attribute__ ((deprecated("Use the variant of ranges::mismatch that takes an upper bound for " "both sequences"))) mismatch_result< borrowed_iterator_t< Rng1 > |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I1 , typename S1 , typename I2 , typename C = equal_to, typename P1 = identity, typename P2 = identity> | |
requires input_iterator< I1 > &&sentinel_for< S1, I1 > &&input_iterator< I2 > &&indirect_relation< C, projected< I1, P1 >, projected< I2, P2 > > | ranges::__attribute__ ((deprecated("Use the variant of ranges::mismatch that takes an upper bound for " "both sequences"))) mismatch_result< I1 |
function template mismatch | |
template<typename Rng0 , typename I1Ref , typename O , typename F , typename P0 = identity, typename P1 = identity> | |
requires input_range< Rng0 > &&input_iterator< uncvref_t< I1Ref > > &&weakly_incrementable< O > &©_constructible< F > &&indirectly_writable< O, indirect_result_t< F &, projected< iterator_t< Rng0 >, P0 >, projected< uncvref_t< I1Ref >, P1 > > > | ranges::__attribute__ ((deprecated("Use the variant of ranges::transform that takes an upper bound " "for both input ranges"))) binary_transform_result< borrowed_iterator_t< Rng0 > |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I0 , typename S0 , typename I1 , typename O , typename F , typename P0 = identity, typename P1 = identity> | |
requires input_iterator< I0 > &&sentinel_for< S0, I0 > &&input_iterator< I1 > &&weakly_incrementable< O > &©_constructible< F > &&indirectly_writable< O, indirect_result_t< F &, projected< I0, P0 >, projected< I1, P1 > > > | ranges::__attribute__ ((deprecated("Use the variant of ranges::transform that takes an upper bound " "for both input ranges"))) binary_transform_result< I0 |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename C = equal_to, typename P = identity> | |
requires forward_iterator< I > &&sentinel_for< S, I > &&indirect_relation< C, projected< I, P > > I | ranges::adjacent_find (I first, S last, C pred=C{}, P proj=P{}) |
function template adjacent_find More... | |
template<typename Rng , typename C = equal_to, typename P = identity> | |
requires forward_range< Rng > &&indirect_relation< C, projected< iterator_t< Rng >, P > > borrowed_iterator_t< Rng > | ranges::adjacent_find (Rng &&rng, C pred=C{}, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename Pred , typename Proj = identity> | |
requires permutable< I > &&sentinel_for< S, I > &&indirect_relation< Pred, projected< I, Proj > > I | ranges::adjacent_remove_if (I first, S last, Pred pred={}, Proj proj={}) |
function adjacent_remove_if More... | |
template<typename Rng , typename Pred , typename Proj = identity> | |
requires forward_range< Rng > &&indirect_relation< Pred, projected< iterator_t< Rng >, Proj > > &&permutable< iterator_t< Rng > > borrowed_iterator_t< Rng > | ranges::adjacent_remove_if (Rng &&rng, Pred pred, Proj proj={}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename F , typename P = identity> | |
requires input_iterator< I > &&sentinel_for< S, I > &&indirect_unary_predicate< F, projected< I, P > > bool | ranges::all_of (I first, S last, F pred, P proj=P{}) |
function template all_of | |
template<typename Rng , typename F , typename P = identity> | |
requires input_range< Rng > &&indirect_unary_predicate< F, projected< iterator_t< Rng >, P > > bool | ranges::all_of (Rng &&rng, F pred, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename F , typename P = identity> | |
requires input_iterator< I > &&sentinel_for< S, I > &&indirect_unary_predicate< F, projected< I, P > > bool | ranges::any_of (I first, S last, F pred, P proj=P{}) |
function template any_of | |
template<typename Rng , typename F , typename P = identity> | |
requires input_range< Rng > &&indirect_unary_predicate< F, projected< iterator_t< Rng >, P > > bool | ranges::any_of (Rng &&rng, F pred, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename V , typename C = less, typename P = identity> | |
requires forward_iterator< I > &&sentinel_for< S, I > &&indirect_strict_weak_order< C, V const *, projected< I, P > > bool | ranges::binary_search (I first, S last, V const &val, C pred=C{}, P proj=P{}) |
function template binary_search More... | |
template<typename Rng , typename V , typename C = less, typename P = identity> | |
requires forward_range< Rng > &&indirect_strict_weak_order< C, V const *, projected< iterator_t< Rng >, P > > bool | ranges::binary_search (Rng &&rng, V const &val, C pred=C{}, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename T , typename P = identity> | |
requires input_iterator< I > &&sentinel_for< S, I > &&constexpr indirect_relation< equal_to, projected< I, P >, const T * > bool | ranges::contains (I first, S last, const T &val, P proj={}) |
function template contains | |
template<typename Rng , typename T , typename P = identity> | |
requires input_range< Rng > &&constexpr indirect_relation< equal_to, projected< iterator_t< Rng >, P >, const T * > bool | ranges::contains (Rng &&rng, const T &val, P proj={}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename O > | |
requires input_iterator< I > &&sentinel_for< S, I > &&weakly_incrementable< O > &&constexpr indirectly_copyable< I, O > copy_result< I, O > | ranges::copy (I first, S last, O out) |
function template copy | |
template<typename Rng , typename O > | |
requires input_range< Rng > &&weakly_incrementable< O > &&constexpr indirectly_copyable< iterator_t< Rng >, O > copy_result< borrowed_iterator_t< Rng >, O > | ranges::copy (Rng &&rng, O out) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename O > | |
requires bidirectional_iterator< I > &&sentinel_for< S, I > &&bidirectional_iterator< O > &&indirectly_copyable< I, O > copy_backward_result< I, O > | ranges::copy_backward (I first, S end_, O out) |
function template copy_backward | |
template<typename Rng , typename O > | |
requires bidirectional_range< Rng > &&bidirectional_iterator< O > &&indirectly_copyable< iterator_t< Rng >, O > copy_backward_result< borrowed_iterator_t< Rng >, O > | ranges::copy_backward (Rng &&rng, O out) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename O , typename F , typename P = identity> | |
requires input_iterator< I > &&sentinel_for< S, I > &&weakly_incrementable< O > &&indirect_unary_predicate< F, projected< I, P > > &&indirectly_copyable< I, O > copy_if_result< I, O > | ranges::copy_if (I first, S last, O out, F pred, P proj=P{}) |
function template copy_if | |
template<typename Rng , typename O , typename F , typename P = identity> | |
requires input_range< Rng > &&weakly_incrementable< O > &&indirect_unary_predicate< F, projected< iterator_t< Rng >, P > > &&indirectly_copyable< iterator_t< Rng >, O > copy_if_result< borrowed_iterator_t< Rng >, O > | ranges::copy_if (Rng &&rng, O out, F pred, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename O , typename P = identity> | |
requires input_iterator< I > &&weakly_incrementable< O > &&indirectly_copyable< I, O > copy_n_result< I, O > | ranges::copy_n (I first, iter_difference_t< I > n, O out) |
function template copy_n | |
template<typename I , typename S , typename V , typename P = identity> | |
requires input_iterator< I > &&sentinel_for< S, I > &&indirect_relation< equal_to, projected< I, P >, V const * > iter_difference_t< I > | ranges::count (I first, S last, V const &val, P proj=P{}) |
function template count | |
template<typename Rng , typename V , typename P = identity> | |
requires input_range< Rng > &&indirect_relation< equal_to, projected< iterator_t< Rng >, P >, V const * > iter_difference_t< iterator_t< Rng > > | ranges::count (Rng &&rng, V const &val, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename R , typename P = identity> | |
requires input_iterator< I > &&sentinel_for< S, I > &&indirect_unary_predicate< R, projected< I, P > > iter_difference_t< I > | ranges::count_if (I first, S last, R pred, P proj=P{}) |
function template count_if | |
template<typename Rng , typename R , typename P = identity> | |
requires input_range< Rng > &&indirect_unary_predicate< R, projected< iterator_t< Rng >, P > > iter_difference_t< iterator_t< Rng > > | ranges::count_if (Rng &&rng, R pred, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
constexpr P1 bool | ranges::ends_with (I0 begin0, S0 end0, I1 begin1, S1 end1, C pred=C{}, P0 proj0=P0{}, P1 proj1=P1{}) |
constexpr P1 bool | ranges::ends_with (Rng0 &&rng0, Rng1 &&rng1, C pred=C{}, P0 proj0=P0{}, P1 proj1=P1{}) |
requires input_iterator< I0 > &&sentinel_for< S0, I0 > &&input_iterator< I1 > &&indirectly_comparable< I0, I1, C, P0, P1 > S0 I1 C P0 P1 I0 &&input_iterator< I1 > &&sentinel_for< S1, I1 > &&constexpr indirectly_comparable< I0, I1, C, P0, P1 > bool | ranges::equal (I0 begin0, S0 end0, I1 begin1, S1 end1, C pred=C{}, P0 proj0=P0{}, P1 proj1=P1{}) |
requires input_range< Rng0 > &&input_iterator< uncvref_t< I1Ref > > &&indirectly_comparable< iterator_t< Rng0 >, uncvref_t< I1Ref >, C, P0, P1 > I1Ref C P0 P1 constexpr P1 bool | ranges::equal (Rng0 &&rng0, Rng1 &&rng1, C pred=C{}, P0 proj0=P0{}, P1 proj1=P1{}) |
template<typename I , typename S , typename V , typename C = less, typename P = identity> | |
requires forward_iterator< I > &&sentinel_for< S, I > &&indirect_strict_weak_order< C, V const *, projected< I, P > > subrange< I > | ranges::equal_range (I first, S last, V const &val, C pred=C{}, P proj=P{}) |
function template equal_range | |
template<typename Rng , typename V , typename C = less, typename P = identity> | |
requires forward_range< Rng > &&indirect_strict_weak_order< C, V const *, projected< iterator_t< Rng >, P > > borrowed_subrange_t< Rng > | ranges::equal_range (Rng &&rng, V const &val, C pred=C{}, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename O , typename S , typename V > | |
requires output_iterator< O, V const & > &&sentinel_for< S, O > O | ranges::fill (O first, S last, V const &val) |
function template fill | |
template<typename Rng , typename V > | |
requires output_range< Rng, V const & > borrowed_iterator_t< Rng > | ranges::fill (Rng &&rng, V const &val) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename O , typename V > | |
requires output_iterator< O, V const & > O | ranges::fill_n (O first, iter_difference_t< O > n, V const &val) |
function template equal | |
template<typename I , typename S , typename V , typename P = identity> | |
requires input_iterator< I > &&sentinel_for< S, I > &&constexpr indirect_relation< equal_to, projected< I, P >, V const * > I | ranges::find (I first, S last, V const &val, P proj=P{}) |
template function find More... | |
template<typename Rng , typename V , typename P = identity> | |
requires input_range< Rng > &&constexpr indirect_relation< equal_to, projected< iterator_t< Rng >, P >, V const * > borrowed_iterator_t< Rng > | ranges::find (Rng &&rng, V const &val, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I1 , typename S1 , typename I2 , typename S2 , typename R = equal_to, typename P = identity> | |
requires forward_iterator< I1 > &&sentinel_for< S1, I1 > &&forward_iterator< I2 > &&sentinel_for< S2, I2 > &&indirect_relation< R, projected< I1, P >, I2 > subrange< I1 > | ranges::find_end (I1 begin1, S1 end1, I2 begin2, S2 end2, R pred=R{}, P proj=P{}) |
function template find_end | |
template<typename Rng1 , typename Rng2 , typename R = equal_to, typename P = identity> | |
requires forward_range< Rng1 > &&forward_range< Rng2 > &&indirect_relation< R, projected< iterator_t< Rng1 >, P >, iterator_t< Rng2 > > borrowed_subrange_t< Rng1 > | ranges::find_end (Rng1 &&rng1, Rng2 &&rng2, R pred=R{}, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I0 , typename S0 , typename I1 , typename S1 , typename R = equal_to, typename P0 = identity, typename P1 = identity> | |
requires input_iterator< I0 > &&sentinel_for< S0, I0 > &&forward_iterator< I1 > &&sentinel_for< S1, I1 > &&constexpr indirect_relation< R, projected< I0, P0 >, projected< I1, P1 > > I0 | ranges::find_first_of (I0 begin0, S0 end0, I1 begin1, S1 end1, R pred=R{}, P0 proj0=P0{}, P1 proj1=P1{}) |
function template find_first_of | |
template<typename Rng0 , typename Rng1 , typename R = equal_to, typename P0 = identity, typename P1 = identity> | |
requires input_range< Rng0 > &&forward_range< Rng1 > &&constexpr indirect_relation< R, projected< iterator_t< Rng0 >, P0 >, projected< iterator_t< Rng1 >, P1 > > borrowed_iterator_t< Rng0 > | ranges::find_first_of (Rng0 &&rng0, Rng1 &&rng1, R pred=R{}, P0 proj0=P0{}, P1 proj1=P1{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename F , typename P = identity> | |
requires input_iterator< I > &&sentinel_for< S, I > &&indirect_unary_predicate< F, projected< I, P > > I | ranges::find_if (I first, S last, F pred, P proj=P{}) |
template function find More... | |
template<typename Rng , typename F , typename P = identity> | |
requires input_range< Rng > &&indirect_unary_predicate< F, projected< iterator_t< Rng >, P > > borrowed_iterator_t< Rng > | ranges::find_if (Rng &&rng, F pred, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename F , typename P = identity> | |
requires input_iterator< I > &&sentinel_for< S, I > &&indirect_unary_predicate< F, projected< I, P > > I | ranges::find_if_not (I first, S last, F pred, P proj=P{}) |
template function find_if_not More... | |
template<typename Rng , typename F , typename P = identity> | |
requires input_range< Rng > &&indirect_unary_predicate< F, projected< iterator_t< Rng >, P > > borrowed_iterator_t< Rng > | ranges::find_if_not (Rng &&rng, F pred, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename F , typename P = identity> | |
requires input_iterator< I > &&sentinel_for< S, I > &&indirectly_unary_invocable< F, projected< I, P > > for_each_result< I, F > | ranges::for_each (I first, S last, F fun, P proj=P{}) |
function template for_each | |
template<typename Rng , typename F , typename P = identity> | |
requires input_range< Rng > &&indirectly_unary_invocable< F, projected< iterator_t< Rng >, P > > for_each_result< borrowed_iterator_t< Rng >, F > | ranges::for_each (Rng &&rng, F fun, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename F , typename P = identity> | |
requires input_iterator< I > &&indirectly_unary_invocable< F, projected< I, P > > I | ranges::for_each_n (I first, iter_difference_t< I > n, F fun, P proj=P{}) |
function template for_each_n | |
template<typename Rng , typename F , typename P = identity> | |
requires input_range< Rng > &&indirectly_unary_invocable< F, projected< iterator_t< Rng >, P > > borrowed_iterator_t< Rng > | ranges::for_each_n (Rng &&rng, range_difference_t< Rng > n, F fun, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename O , typename S , typename F > | |
requires invocable< F & > &&output_iterator< O, invoke_result_t< F & > > &&sentinel_for< S, O > generate_result< O, F > | ranges::generate (O first, S last, F fun) |
function template generate_n | |
template<typename Rng , typename F > | |
requires invocable< F & > &&output_range< Rng, invoke_result_t< F & > > generate_result< borrowed_iterator_t< Rng >, F > | ranges::generate (Rng &&rng, F fun) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename O , typename F > | |
requires invocable< F & > &&output_iterator< O, invoke_result_t< F & > > generate_n_result< O, F > | ranges::generate_n (O first, iter_difference_t< O > n, F fun) |
function template generate_n | |
ranges::I1 (input_iterator< I1 > &&sized_sentinel_for< S1, I1 >)) &&indirectly_comparable< I0 | |
template<typename I1 , typename S1 , typename I2 , typename S2 , typename C = less, typename P1 = identity, typename P2 = identity> | |
requires input_iterator< I1 > &&sentinel_for< S1, I1 > &&input_iterator< I2 > &&sentinel_for< S2, I2 > &&indirect_strict_weak_order< C, projected< I1, P1 >, projected< I2, P2 > > bool | ranges::includes (I1 begin1, S1 end1, I2 begin2, S2 end2, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{}) |
function template includes | |
template<typename Rng1 , typename Rng2 , typename C = less, typename P1 = identity, typename P2 = identity> | |
requires input_range< Rng1 > &&input_range< Rng2 > &&indirect_strict_weak_order< C, projected< iterator_t< Rng1 >, P1 >, projected< iterator_t< Rng2 >, P2 > > bool | ranges::includes (Rng1 &&rng1, Rng2 &&rng2, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename C = less, typename P = identity> | |
requires bidirectional_iterator< I > &&sortable< I, C, P > I | ranges::inplace_merge (I first, I middle, S last, C pred=C{}, P proj=P{}) |
function template inplace_merge | |
template<typename Rng , typename C = less, typename P = identity> | |
requires bidirectional_range< Rng > &&sortable< iterator_t< Rng >, C, P > borrowed_iterator_t< Rng > | ranges::inplace_merge (Rng &&rng, iterator_t< Rng > middle, C pred=C{}, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename C = less, typename P = identity> | |
requires random_access_iterator< I > &&sentinel_for< S, I > &&indirect_strict_weak_order< C, projected< I, P > > bool | ranges::is_heap (I first, S last, C pred=C{}, P proj=P{}) |
function template is_heap | |
template<typename Rng , typename C = less, typename P = identity> | |
requires random_access_range< Rng > &&indirect_strict_weak_order< C, projected< iterator_t< Rng >, P > > bool | ranges::is_heap (Rng &&rng, C pred=C{}, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename C = less, typename P = identity> | |
requires random_access_iterator< I > &&sentinel_for< S, I > &&indirect_strict_weak_order< C, projected< I, P > > I | ranges::is_heap_until (I first, S last, C pred=C{}, P proj=P{}) |
function template is_heap_until | |
template<typename Rng , typename C = less, typename P = identity> | |
requires random_access_range< Rng > &&indirect_strict_weak_order< C, projected< iterator_t< Rng >, P > > borrowed_iterator_t< Rng > | ranges::is_heap_until (Rng &&rng, C pred=C{}, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename C , typename P = identity> | |
requires input_iterator< I > &&sentinel_for< S, I > &&indirect_unary_predicate< C, projected< I, P > > bool | ranges::is_partitioned (I first, S last, C pred, P proj=P{}) |
function template is_partitioned | |
template<typename Rng , typename C , typename P = identity> | |
requires input_range< Rng > &&indirect_unary_predicate< C, projected< iterator_t< Rng >, P > > bool | ranges::is_partitioned (Rng &&rng, C pred, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
requires forward_iterator< I1 > &&sentinel_for< S1, I1 > &&forward_iterator< I2 > &&indirectly_comparable< I1, I2, C, P1, P2 > S1 I2 C P1 P2 I1 &&forward_iterator< I2 > &&sentinel_for< S2, I2 > &&indirectly_comparable< I1, I2, C, P1, P2 > bool | ranges::is_permutation (I1 begin1, S1 end1, I2 begin2, S2 end2, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{}) |
requires forward_range< Rng1 > &&forward_iterator< uncvref_t< I2Ref > > &&indirectly_comparable< iterator_t< Rng1 >, uncvref_t< I2Ref >, C, P1, P2 > I2Ref C P1 P2 P2 bool | ranges::is_permutation (Rng1 &&rng1, Rng2 &&rng2, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{}) |
template<typename I , typename S , typename R = less, typename P = identity> | |
requires forward_iterator< I > &&sentinel_for< S, I > &&indirect_strict_weak_order< R, projected< I, P > > bool | ranges::is_sorted (I first, S last, R rel=R{}, P proj=P{}) |
template function is_sorted More... | |
template<typename Rng , typename R = less, typename P = identity> | |
requires forward_range< Rng > &&indirect_strict_weak_order< R, projected< iterator_t< Rng >, P > > bool | ranges::is_sorted (Rng &&rng, R rel=R{}, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename R = less, typename P = identity> | |
requires forward_iterator< I > &&sentinel_for< S, I > &&indirect_strict_weak_order< R, projected< I, P > > I | ranges::is_sorted_until (I first, S last, R pred=R{}, P proj=P{}) |
template function is_sorted_until More... | |
template<typename Rng , typename R = less, typename P = identity> | |
requires forward_range< Rng > &&indirect_strict_weak_order< R, projected< iterator_t< Rng >, P > > borrowed_iterator_t< Rng > | ranges::is_sorted_until (Rng &&rng, R pred=R{}, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I0 , typename S0 , typename I1 , typename S1 , typename C = less, typename P0 = identity, typename P1 = identity> | |
requires input_iterator< I0 > &&sentinel_for< S0, I0 > &&input_iterator< I1 > &&sentinel_for< S1, I1 > &&indirect_strict_weak_order< C, projected< I0, P0 >, projected< I1, P1 > > bool | ranges::lexicographical_compare (I0 begin0, S0 end0, I1 begin1, S1 end1, C pred=C{}, P0 proj0=P0{}, P1 proj1=P1{}) |
function template lexicographical_compare | |
template<typename Rng0 , typename Rng1 , typename C = less, typename P0 = identity, typename P1 = identity> | |
requires input_range< Rng0 > &&input_range< Rng1 > &&indirect_strict_weak_order< C, projected< iterator_t< Rng0 >, P0 >, projected< iterator_t< Rng1 >, P1 > > bool | ranges::lexicographical_compare (Rng0 &&rng0, Rng1 &&rng1, C pred=C{}, P0 proj0=P0{}, P1 proj1=P1{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename V , typename C = less, typename P = identity> | |
requires forward_iterator< I > &&sentinel_for< S, I > &&indirect_strict_weak_order< C, V const *, projected< I, P > > I | ranges::lower_bound (I first, S last, V const &val, C pred=C{}, P proj=P{}) |
function template lower_bound | |
template<typename Rng , typename V , typename C = less, typename P = identity> | |
requires forward_range< Rng > &&indirect_strict_weak_order< C, V const *, projected< iterator_t< Rng >, P > > borrowed_iterator_t< Rng > | ranges::lower_bound (Rng &&rng, V const &val, C pred=C{}, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename C = less, typename P = identity> | |
requires random_access_iterator< I > &&sentinel_for< S, I > &&sortable< I, C, P > I | ranges::make_heap (I first, S last, C pred=C{}, P proj=P{}) |
function template make_heap | |
template<typename Rng , typename C = less, typename P = identity> | |
requires random_access_range< Rng > &&sortable< iterator_t< Rng >, C, P > borrowed_iterator_t< Rng > | ranges::make_heap (Rng &&rng, C pred=C{}, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename Rng , typename C = less, typename P = identity> | |
requires input_range< Rng > &&indirect_strict_weak_order< C, projected< iterator_t< Rng >, P > > &&constexpr indirectly_copyable_storable< iterator_t< Rng >, range_value_t< Rng > * > range_value_t< Rng > | ranges::max (Rng &&rng, C pred=C{}, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename T , typename C = less, typename P = identity> | |
requires copyable< T > &&constexpr indirect_strict_weak_order< C, projected< T const *, P > > T | ranges::max (std::initializer_list< T > const &&rng, C pred=C{}, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename T , typename C = less, typename P = identity> | |
requires constexpr indirect_strict_weak_order< C, projected< T const *, P > > T const & | ranges::max (T const &a, T const &b, C pred=C{}, P proj=P{}) |
function template max | |
template<typename I , typename S , typename C = less, typename P = identity> | |
requires forward_iterator< I > &&sentinel_for< S, I > &&indirect_strict_weak_order< C, projected< I, P > > I | ranges::max_element (I first, S last, C pred=C{}, P proj=P{}) |
function template max_element | |
template<typename Rng , typename C = less, typename P = identity> | |
requires forward_range< Rng > &&indirect_strict_weak_order< C, projected< iterator_t< Rng >, P > > borrowed_iterator_t< Rng > | ranges::max_element (Rng &&rng, C pred=C{}, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I0 , typename S0 , typename I1 , typename S1 , typename O , typename C = less, typename P0 = identity, typename P1 = identity> | |
requires sentinel_for< S0, I0 > &&sentinel_for< S1, I1 > &&mergeable< I0, I1, O, C, P0, P1 > merge_result< I0, I1, O > | ranges::merge (I0 begin0, S0 end0, I1 begin1, S1 end1, O out, C pred=C{}, P0 proj0=P0{}, P1 proj1=P1{}) |
function template merge | |
template<typename Rng0 , typename Rng1 , typename O , typename C = less, typename P0 = identity, typename P1 = identity> | |
requires range< Rng0 > &&range< Rng1 > &&mergeable< iterator_t< Rng0 >, iterator_t< Rng1 >, O, C, P0, P1 > merge_result< borrowed_iterator_t< Rng0 >, borrowed_iterator_t< Rng1 >, O > | ranges::merge (Rng0 &&rng0, Rng1 &&rng1, O out, C pred=C{}, P0 proj0=P0{}, P1 proj1=P1{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename Rng , typename C = less, typename P = identity> | |
requires input_range< Rng > &&indirect_strict_weak_order< C, projected< iterator_t< Rng >, P > > &&constexpr indirectly_copyable_storable< iterator_t< Rng >, range_value_t< Rng > * > range_value_t< Rng > | ranges::min (Rng &&rng, C pred=C{}, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename T , typename C = less, typename P = identity> | |
requires copyable< T > &&constexpr indirect_strict_weak_order< C, projected< T const *, P > > T | ranges::min (std::initializer_list< T > const &&rng, C pred=C{}, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename T , typename C = less, typename P = identity> | |
requires constexpr indirect_strict_weak_order< C, projected< T const *, P > > T const & | ranges::min (T const &a, T const &b, C pred=C{}, P proj=P{}) |
function template min | |
template<typename I , typename S , typename C = less, typename P = identity> | |
requires forward_iterator< I > &&sentinel_for< S, I > &&indirect_strict_weak_order< C, projected< I, P > > I | ranges::min_element (I first, S last, C pred=C{}, P proj=P{}) |
function template min_element | |
template<typename Rng , typename C = less, typename P = identity> | |
requires forward_range< Rng > &&indirect_strict_weak_order< C, projected< iterator_t< Rng >, P > > borrowed_iterator_t< Rng > | ranges::min_element (Rng &&rng, C pred=C{}, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename Rng , typename C = less, typename P = identity> | |
requires input_range< Rng > &&indirect_strict_weak_order< C, projected< iterator_t< Rng >, P > > &&constexpr indirectly_copyable_storable< iterator_t< Rng >, range_value_t< Rng > * > minmax_result< range_value_t< Rng > > | ranges::minmax (Rng &&rng, C pred=C{}, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename T , typename C = less, typename P = identity> | |
requires copyable< T > &&constexpr indirect_strict_weak_order< C, projected< T const *, P > > minmax_result< T > | ranges::minmax (std::initializer_list< T > const &&rng, C pred=C{}, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename T , typename C = less, typename P = identity> | |
requires constexpr indirect_strict_weak_order< C, projected< T const *, P > > minmax_result< T const & > | ranges::minmax (T const &a, T const &b, C pred=C{}, P proj=P{}) |
function template minmax | |
template<typename I , typename S , typename C = less, typename P = identity> | |
requires forward_iterator< I > &&sentinel_for< S, I > &&indirect_strict_weak_order< C, projected< I, P > > minmax_element_result< I > | ranges::minmax_element (I first, S last, C pred=C{}, P proj=P{}) |
function template minmax_element | |
template<typename Rng , typename C = less, typename P = identity> | |
requires forward_range< Rng > &&indirect_strict_weak_order< C, projected< iterator_t< Rng >, P > > minmax_element_result< borrowed_iterator_t< Rng > > | ranges::minmax_element (Rng &&rng, C pred=C{}, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
requires input_iterator< I1 > &&sentinel_for< S1, I1 > &&input_iterator< I2 > &&indirect_relation< C, projected< I1, P1 >, projected< I2, P2 > > I2 | ranges::mismatch (I1 begin1, S1 end1, I2 begin2, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{}) |
template<typename I1 , typename S1 , typename I2 , typename S2 , typename C = equal_to, typename P1 = identity, typename P2 = identity> | |
requires input_iterator< I1 > &&sentinel_for< S1, I1 > &&input_iterator< I2 > &&sentinel_for< S2, I2 > &&indirect_relation< C, projected< I1, P1 >, projected< I2, P2 > > mismatch_result< I1, I2 > | ranges::mismatch (I1 begin1, S1 end1, I2 begin2, S2 end2, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
requires input_range< Rng1 > &&input_iterator< uncvref_t< I2Ref > > &&indirect_relation< C, projected< iterator_t< Rng1 >, P1 >, projected< uncvref_t< I2Ref >, P2 > > uncvref_t< I2Ref > | ranges::mismatch (Rng1 &&rng1, I2Ref &&begin2, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{}) |
template<typename Rng1 , typename Rng2 , typename C = equal_to, typename P1 = identity, typename P2 = identity> | |
requires input_range< Rng1 > &&input_range< Rng2 > &&indirect_relation< C, projected< iterator_t< Rng1 >, P1 >, projected< iterator_t< Rng2 >, P2 > > mismatch_result< borrowed_iterator_t< Rng1 >, borrowed_iterator_t< Rng2 > > | ranges::mismatch (Rng1 &&rng1, Rng2 &&rng2, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename O > | |
requires input_iterator< I > &&sentinel_for< S, I > &&weakly_incrementable< O > &&indirectly_movable< I, O > move_result< I, O > | ranges::move (I first, S last, O out) |
function template move | |
template<typename Rng , typename O > | |
requires input_range< Rng > &&weakly_incrementable< O > &&indirectly_movable< iterator_t< Rng >, O > move_result< borrowed_iterator_t< Rng >, O > | ranges::move (Rng &&rng, O out) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename O > | |
requires bidirectional_iterator< I > &&sentinel_for< S, I > &&bidirectional_iterator< O > &&indirectly_movable< I, O > move_backward_result< I, O > | ranges::move_backward (I first, S end_, O out) |
function template move_backward | |
template<typename Rng , typename O > | |
requires bidirectional_range< Rng > &&bidirectional_iterator< O > &&indirectly_movable< iterator_t< Rng >, O > move_backward_result< borrowed_iterator_t< Rng >, O > | ranges::move_backward (Rng &&rng, O out) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename C = less, typename P = identity> | |
requires bidirectional_iterator< I > &&sentinel_for< S, I > &&sortable< I, C, P > bool | ranges::next_permutation (I first, S end_, C pred=C{}, P proj=P{}) |
function template next_permutation | |
template<typename Rng , typename C = less, typename P = identity> | |
requires bidirectional_range< Rng > &&sortable< iterator_t< Rng >, C, P > bool | ranges::next_permutation (Rng &&rng, C pred=C{}, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename F , typename P = identity> | |
requires input_iterator< I > &&sentinel_for< S, I > &&indirect_unary_predicate< F, projected< I, P > > bool | ranges::none_of (I first, S last, F pred, P proj=P{}) |
function template none_of | |
template<typename Rng , typename F , typename P = identity> | |
requires input_range< Rng > &&indirect_unary_predicate< F, projected< iterator_t< Rng >, P > > bool | ranges::none_of (Rng &&rng, F pred, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename C = less, typename P = identity> | |
requires random_access_iterator< I > &&sortable< I, C, P > I | ranges::nth_element (I first, I nth, S end_, C pred=C{}, P proj=P{}) |
function template nth_element | |
template<typename Rng , typename C = less, typename P = identity> | |
requires random_access_range< Rng > &&sortable< iterator_t< Rng >, C, P > borrowed_iterator_t< Rng > | ranges::nth_element (Rng &&rng, iterator_t< Rng > nth, C pred=C{}, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename C = less, typename P = identity> | |
requires sortable< I, C, P > &&random_access_iterator< I > &&sentinel_for< S, I > I | ranges::partial_sort (I first, I middle, S last, C pred=C{}, P proj=P{}) |
function template partial_sort | |
template<typename Rng , typename C = less, typename P = identity> | |
requires sortable< iterator_t< Rng >, C, P > &&random_access_range< Rng > borrowed_iterator_t< Rng > | ranges::partial_sort (Rng &&rng, iterator_t< Rng > middle, C pred=C{}, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename SI , typename O , typename SO , typename C = less, typename PI = identity, typename PO = identity> | |
requires input_iterator< I > &&sentinel_for< SI, I > &&random_access_iterator< O > &&sentinel_for< SO, O > &&indirectly_copyable< I, O > &&sortable< O, C, PO > &&indirect_strict_weak_order< C, projected< I, PI >, projected< O, PO > > O | ranges::partial_sort_copy (I first, SI last, O out_begin, SO out_end, C pred=C{}, PI in_proj=PI{}, PO out_proj=PO{}) |
function template partial_sort_copy | |
template<typename InRng , typename OutRng , typename C = less, typename PI = identity, typename PO = identity> | |
requires input_range< InRng > &&random_access_range< OutRng > &&indirectly_copyable< iterator_t< InRng >, iterator_t< OutRng > > &&sortable< iterator_t< OutRng >, C, PO > &&indirect_strict_weak_order< C, projected< iterator_t< InRng >, PI >, projected< iterator_t< OutRng >, PO > > borrowed_iterator_t< OutRng > | ranges::partial_sort_copy (InRng &&in_rng, OutRng &&out_rng, C pred=C{}, PI in_proj=PI{}, PO out_proj=PO{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename C , typename P = identity> | |
requires permutable< I > &&sentinel_for< S, I > &&indirect_unary_predicate< C, projected< I, P > > I | ranges::partition (I first, S last, C pred, P proj=P{}) |
function template partition | |
template<typename Rng , typename C , typename P = identity> | |
requires forward_range< Rng > &&permutable< iterator_t< Rng > > &&indirect_unary_predicate< C, projected< iterator_t< Rng >, P > > borrowed_iterator_t< Rng > | ranges::partition (Rng &&rng, C pred, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename O0 , typename O1 , typename C , typename P = identity> | |
requires input_iterator< I > &&sentinel_for< S, I > &&weakly_incrementable< O0 > &&weakly_incrementable< O1 > &&indirectly_copyable< I, O0 > &&indirectly_copyable< I, O1 > &&indirect_unary_predicate< C, projected< I, P > > partition_copy_result< I, O0, O1 > | ranges::partition_copy (I first, S last, O0 o0, O1 o1, C pred, P proj=P{}) |
function template partition_copy | |
template<typename Rng , typename O0 , typename O1 , typename C , typename P = identity> | |
requires input_range< Rng > &&weakly_incrementable< O0 > &&weakly_incrementable< O1 > &&indirectly_copyable< iterator_t< Rng >, O0 > &&indirectly_copyable< iterator_t< Rng >, O1 > &&indirect_unary_predicate< C, projected< iterator_t< Rng >, P > > partition_copy_result< borrowed_iterator_t< Rng >, O0, O1 > | ranges::partition_copy (Rng &&rng, O0 o0, O1 o1, C pred, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename C , typename P = identity> | |
requires forward_iterator< I > &&sentinel_for< S, I > &&indirect_unary_predicate< C, projected< I, P > > I | ranges::partition_point (I first, S last, C pred, P proj=P{}) |
function template partition_point | |
template<typename Rng , typename C , typename P = identity> | |
requires forward_range< Rng > &&indirect_unary_predicate< C, projected< iterator_t< Rng >, P > > borrowed_iterator_t< Rng > | ranges::partition_point (Rng &&rng, C pred, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename C = less, typename P = identity> | |
requires random_access_iterator< I > &&sentinel_for< S, I > &&sortable< I, C, P > I | ranges::pop_heap (I first, S last, C pred=C{}, P proj=P{}) |
function template pop_heap | |
template<typename Rng , typename C = less, typename P = identity> | |
requires random_access_range< Rng > &&sortable< iterator_t< Rng >, C, P > borrowed_iterator_t< Rng > | ranges::pop_heap (Rng &&rng, C pred=C{}, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename C = less, typename P = identity> | |
requires bidirectional_iterator< I > &&sentinel_for< S, I > &&sortable< I, C, P > bool | ranges::prev_permutation (I first, S end_, C pred=C{}, P proj=P{}) |
function template prev_permutation | |
template<typename Rng , typename C = less, typename P = identity> | |
requires bidirectional_range< Rng > &&sortable< iterator_t< Rng >, C, P > bool | ranges::prev_permutation (Rng &&rng, C pred=C{}, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename C = less, typename P = identity> | |
requires random_access_iterator< I > &&sentinel_for< S, I > &&sortable< I, C, P > I | ranges::push_heap (I first, S last, C pred=C{}, P proj=P{}) |
function template push_heap | |
template<typename Rng , typename C = less, typename P = identity> | |
requires random_access_range< Rng > &&sortable< iterator_t< Rng >, C, P > borrowed_iterator_t< Rng > | ranges::push_heap (Rng &&rng, C pred=C{}, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename T , typename P = identity> | |
requires permutable< I > &&sentinel_for< S, I > &&indirect_relation< equal_to, projected< I, P >, T const * > I | ranges::remove (I first, S last, T const &val, P proj=P{}) |
function template remove | |
template<typename Rng , typename T , typename P = identity> | |
requires forward_range< Rng > &&permutable< iterator_t< Rng > > &&indirect_relation< equal_to, projected< iterator_t< Rng >, P >, T const * > borrowed_iterator_t< Rng > | ranges::remove (Rng &&rng, T const &val, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename O , typename T , typename P = identity> | |
requires input_iterator< I > &&sentinel_for< S, I > &&weakly_incrementable< O > &&indirect_relation< equal_to, projected< I, P >, T const * > &&indirectly_copyable< I, O > remove_copy_result< I, O > | ranges::remove_copy (I first, S last, O out, T const &val, P proj=P{}) |
function template remove_copy | |
template<typename Rng , typename O , typename T , typename P = identity> | |
requires input_range< Rng > &&weakly_incrementable< O > &&indirect_relation< equal_to, projected< iterator_t< Rng >, P >, T const * > &&indirectly_copyable< iterator_t< Rng >, O > remove_copy_result< borrowed_iterator_t< Rng >, O > | ranges::remove_copy (Rng &&rng, O out, T const &val, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename O , typename C , typename P = identity> | |
requires input_iterator< I > &&sentinel_for< S, I > &&weakly_incrementable< O > &&indirect_unary_predicate< C, projected< I, P > > &&indirectly_copyable< I, O > remove_copy_if_result< I, O > | ranges::remove_copy_if (I first, S last, O out, C pred, P proj=P{}) |
function template remove_copy_if | |
template<typename Rng , typename O , typename C , typename P = identity> | |
requires input_range< Rng > &&weakly_incrementable< O > &&indirect_unary_predicate< C, projected< iterator_t< Rng >, P > > &&indirectly_copyable< iterator_t< Rng >, O > remove_copy_if_result< borrowed_iterator_t< Rng >, O > | ranges::remove_copy_if (Rng &&rng, O out, C pred, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename C , typename P = identity> | |
requires permutable< I > &&sentinel_for< S, I > &&indirect_unary_predicate< C, projected< I, P > > I | ranges::remove_if (I first, S last, C pred, P proj=P{}) |
function template remove_if | |
template<typename Rng , typename C , typename P = identity> | |
requires forward_range< Rng > &&permutable< iterator_t< Rng > > &&indirect_unary_predicate< C, projected< iterator_t< Rng >, P > > borrowed_iterator_t< Rng > | ranges::remove_if (Rng &&rng, C pred, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename T1 , typename T2 , typename P = identity> | |
requires input_iterator< I > &&sentinel_for< S, I > &&indirectly_writable< I, T2 const & > &&indirect_relation< equal_to, projected< I, P >, T1 const * > I | ranges::replace (I first, S last, T1 const &old_value, T2 const &new_value, P proj={}) |
function template replace | |
template<typename Rng , typename T1 , typename T2 , typename P = identity> | |
requires input_range< Rng > &&indirectly_writable< iterator_t< Rng >, T2 const & > &&indirect_relation< equal_to, projected< iterator_t< Rng >, P >, T1 const * > borrowed_iterator_t< Rng > | ranges::replace (Rng &&rng, T1 const &old_value, T2 const &new_value, P proj={}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename O , typename T1 , typename T2 , typename P = identity> | |
requires input_iterator< I > &&sentinel_for< S, I > &&output_iterator< O, T2 const & > &&indirectly_copyable< I, O > &&indirect_relation< equal_to, projected< I, P >, T1 const * > replace_copy_result< I, O > | ranges::replace_copy (I first, S last, O out, T1 const &old_value, T2 const &new_value, P proj={}) |
function template replace_copy | |
template<typename Rng , typename O , typename T1 , typename T2 , typename P = identity> | |
requires input_range< Rng > &&output_iterator< O, T2 const & > &&indirectly_copyable< iterator_t< Rng >, O > &&indirect_relation< equal_to, projected< iterator_t< Rng >, P >, T1 const * > replace_copy_result< borrowed_iterator_t< Rng >, O > | ranges::replace_copy (Rng &&rng, O out, T1 const &old_value, T2 const &new_value, P proj={}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename O , typename C , typename T , typename P = identity> | |
requires input_iterator< I > &&sentinel_for< S, I > &&output_iterator< O, T const & > &&indirect_unary_predicate< C, projected< I, P > > &&indirectly_copyable< I, O > replace_copy_if_result< I, O > | ranges::replace_copy_if (I first, S last, O out, C pred, T const &new_value, P proj={}) |
function template replace_copy_if | |
template<typename Rng , typename O , typename C , typename T , typename P = identity> | |
requires input_range< Rng > &&output_iterator< O, T const & > &&indirect_unary_predicate< C, projected< iterator_t< Rng >, P > > &&indirectly_copyable< iterator_t< Rng >, O > replace_copy_if_result< borrowed_iterator_t< Rng >, O > | ranges::replace_copy_if (Rng &&rng, O out, C pred, T const &new_value, P proj={}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename C , typename T , typename P = identity> | |
requires input_iterator< I > &&sentinel_for< S, I > &&indirect_unary_predicate< C, projected< I, P > > &&indirectly_writable< I, T const & > I | ranges::replace_if (I first, S last, C pred, T const &new_value, P proj=P{}) |
function template replace_if | |
template<typename Rng , typename C , typename T , typename P = identity> | |
requires input_range< Rng > &&indirect_unary_predicate< C, projected< iterator_t< Rng >, P > > &&indirectly_writable< iterator_t< Rng >, T const & > borrowed_iterator_t< Rng > | ranges::replace_if (Rng &&rng, C pred, T const &new_value, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I0 , typename S0 , typename I1 , typename S1 , typename C = equal_to, typename P0 = identity, typename P1 = identity> | |
ranges::requires ((forward_iterator< I0 > &&sentinel_for< S0, I0 >)||(input_iterator< I0 > &&sized_sentinel_for< S0, I0 >)) &&((forward_iterator< I1 > &&sentinel_for< S1 | |
function template ends_with | |
template<typename Rng0 , typename Rng1 , typename C = equal_to, typename P0 = identity, typename P1 = identity> | |
ranges::requires (forward_range< Rng0 >||(input_range< Rng0 > &&sized_range< Rng0 >)) &&(forward_range< Rng1 >||(input_range< Rng1 > &&sized_range< Rng1 >)) &&indirectly_comparable< iterator_t< Rng0 > | |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S > | |
requires bidirectional_iterator< I > &&sentinel_for< S, I > &&permutable< I > I | ranges::reverse (I first, S end_) |
function template reverse | |
template<typename Rng , typename I = iterator_t<Rng>> | |
requires bidirectional_range< Rng > &&permutable< I > borrowed_iterator_t< Rng > | ranges::reverse (Rng &&rng) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename O > | |
requires bidirectional_iterator< I > &&sentinel_for< S, I > &&weakly_incrementable< O > &&indirectly_copyable< I, O > reverse_copy_result< I, O > | ranges::reverse_copy (I first, S end_, O out) |
function template reverse_copy | |
template<typename Rng , typename O > | |
requires bidirectional_range< Rng > &&weakly_incrementable< O > &&indirectly_copyable< iterator_t< Rng >, O > reverse_copy_result< borrowed_iterator_t< Rng >, O > | ranges::reverse_copy (Rng &&rng, O out) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S > | |
requires permutable< I > &&sentinel_for< S, I > subrange< I > | ranges::rotate (I first, I middle, S last) |
function template rotate | |
template<typename Rng , typename I = iterator_t<Rng>> | |
requires range< Rng > &&permutable< I > borrowed_subrange_t< Rng > | ranges::rotate (Rng &&rng, I middle) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename O , typename P = identity> | |
requires forward_iterator< I > &&sentinel_for< S, I > &&weakly_incrementable< O > &&indirectly_copyable< I, O > rotate_copy_result< I, O > | ranges::rotate_copy (I first, I middle, S last, O out) |
function template rotate_copy | |
template<typename Rng , typename O , typename P = identity> | |
requires range< Rng > &&weakly_incrementable< O > &&indirectly_copyable< iterator_t< Rng >, O > rotate_copy_result< borrowed_iterator_t< Rng >, O > | ranges::rotate_copy (Rng &&rng, iterator_t< Rng > middle, O out) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename O , typename Gen = detail::default_random_engine &> | |
requires input_iterator< I > &&sentinel_for< S, I > &&weakly_incrementable< O > &&indirectly_copyable< I, O > &&uniform_random_bit_generator< std::remove_reference_t< Gen > > &&random_access_iterator< O > forward_iterator< I > sized_sentinel_for< S, I > sample_result< I, O > | ranges::sample (I first, S last, O out, iter_difference_t< O > const n, Gen &&gen=detail::get_random_engine()) |
function template sample | |
template<typename I , typename S , typename ORng , typename Gen = detail::default_random_engine &> | |
requires input_iterator< I > &&sentinel_for< S, I > &&weakly_incrementable< iterator_t< ORng > > &&indirectly_copyable< I, iterator_t< ORng > > &&uniform_random_bit_generator< std::remove_reference_t< Gen > > &&forward_range< ORng > sized_range< ORng > &&random_access_iterator< iterator_t< ORng > > forward_iterator< I > sized_sentinel_for< S, I > sample_result< I, borrowed_iterator_t< ORng > > | ranges::sample (I first, S last, ORng &&out, Gen &&gen=detail::get_random_engine()) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename IRng , typename ORng , typename Gen = detail::default_random_engine &> | |
requires input_range< IRng > &&range< ORng > &&indirectly_copyable< iterator_t< IRng >, iterator_t< ORng > > &&uniform_random_bit_generator< std::remove_reference_t< Gen > > &&random_access_iterator< iterator_t< ORng > > forward_range< IRng > sized_range< IRng > &&forward_range< ORng > sized_range< ORng > sample_result< borrowed_iterator_t< IRng >, borrowed_iterator_t< ORng > > | ranges::sample (IRng &&rng, ORng &&out, Gen &&gen=detail::get_random_engine()) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename Rng , typename O , typename Gen = detail::default_random_engine &> | |
requires input_range< Rng > &&weakly_incrementable< O > &&indirectly_copyable< iterator_t< Rng >, O > &&uniform_random_bit_generator< std::remove_reference_t< Gen > > &&random_access_iterator< O > forward_range< Rng > sized_range< Rng > sample_result< borrowed_iterator_t< Rng >, O > | ranges::sample (Rng &&rng, O out, iter_difference_t< O > const n, Gen &&gen=detail::get_random_engine()) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I1 , typename S1 , typename I2 , typename S2 , typename C = equal_to, typename P1 = identity, typename P2 = identity> | |
requires forward_iterator< I1 > &&sentinel_for< S1, I1 > &&forward_iterator< I2 > &&sentinel_for< S2, I2 > &&indirectly_comparable< I1, I2, C, P1, P2 > subrange< I1 > | ranges::search (I1 begin1, S1 end1, I2 begin2, S2 end2, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{}) |
function template search | |
template<typename Rng1 , typename Rng2 , typename C = equal_to, typename P1 = identity, typename P2 = identity> | |
requires forward_range< Rng1 > &&forward_range< Rng2 > &&indirectly_comparable< iterator_t< Rng1 >, iterator_t< Rng2 >, C, P1, P2 > borrowed_subrange_t< Rng1 > | ranges::search (Rng1 &&rng1, Rng2 &&rng2, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename V , typename C = equal_to, typename P = identity> | |
requires forward_iterator< I > &&sentinel_for< S, I > &&indirectly_comparable< I, V const *, C, P > subrange< I > | ranges::search_n (I first, S last, iter_difference_t< I > cnt, V const &val, C pred=C{}, P proj=P{}) |
function template search_n | |
template<typename Rng , typename V , typename C = equal_to, typename P = identity> | |
requires forward_range< Rng > &&indirectly_comparable< iterator_t< Rng >, V const *, C, P > borrowed_subrange_t< Rng > | ranges::search_n (Rng &&rng, iter_difference_t< iterator_t< Rng >> cnt, V const &val, C pred=C{}, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I1 , typename S1 , typename I2 , typename S2 , typename O , typename C = less, typename P1 = identity, typename P2 = identity> | |
requires sentinel_for< S1, I1 > &&sentinel_for< S2, I2 > &&mergeable< I1, I2, O, C, P1, P2 > set_difference_result< I1, O > | ranges::set_difference (I1 begin1, S1 end1, I2 begin2, S2 end2, O out, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{}) |
function template set_difference | |
template<typename Rng1 , typename Rng2 , typename O , typename C = less, typename P1 = identity, typename P2 = identity> | |
requires range< Rng1 > &&range< Rng2 > &&mergeable< iterator_t< Rng1 >, iterator_t< Rng2 >, O, C, P1, P2 > set_difference_result< borrowed_iterator_t< Rng1 >, O > | ranges::set_difference (Rng1 &&rng1, Rng2 &&rng2, O out, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I1 , typename S1 , typename I2 , typename S2 , typename O , typename C = less, typename P1 = identity, typename P2 = identity> | |
requires sentinel_for< S1, I1 > &&sentinel_for< S2, I2 > &&mergeable< I1, I2, O, C, P1, P2 > O | ranges::set_intersection (I1 begin1, S1 end1, I2 begin2, S2 end2, O out, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{}) |
function template set_intersection | |
template<typename Rng1 , typename Rng2 , typename O , typename C = less, typename P1 = identity, typename P2 = identity> | |
requires range< Rng1 > &&range< Rng2 > &&mergeable< iterator_t< Rng1 >, iterator_t< Rng2 >, O, C, P1, P2 > O | ranges::set_intersection (Rng1 &&rng1, Rng2 &&rng2, O out, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I1 , typename S1 , typename I2 , typename S2 , typename O , typename C = less, typename P1 = identity, typename P2 = identity> | |
requires sentinel_for< S1, I1 > &&sentinel_for< S2, I2 > &&mergeable< I1, I2, O, C, P1, P2 > set_symmetric_difference_result< I1, I2, O > | ranges::set_symmetric_difference (I1 begin1, S1 end1, I2 begin2, S2 end2, O out, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{}) |
function template set_symmetric_difference | |
template<typename Rng1 , typename Rng2 , typename O , typename C = less, typename P1 = identity, typename P2 = identity> | |
requires range< Rng1 > &&range< Rng2 > &&mergeable< iterator_t< Rng1 >, iterator_t< Rng2 >, O, C, P1, P2 > set_symmetric_difference_result< borrowed_iterator_t< Rng1 >, borrowed_iterator_t< Rng2 >, O > | ranges::set_symmetric_difference (Rng1 &&rng1, Rng2 &&rng2, O out, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I1 , typename S1 , typename I2 , typename S2 , typename O , typename C = less, typename P1 = identity, typename P2 = identity> | |
requires sentinel_for< S1, I1 > &&sentinel_for< S2, I2 > &&mergeable< I1, I2, O, C, P1, P2 > set_union_result< I1, I2, O > | ranges::set_union (I1 begin1, S1 end1, I2 begin2, S2 end2, O out, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{}) |
function template set_union | |
template<typename Rng1 , typename Rng2 , typename O , typename C = less, typename P1 = identity, typename P2 = identity> | |
requires range< Rng1 > &&range< Rng2 > &&mergeable< iterator_t< Rng1 >, iterator_t< Rng2 >, O, C, P1, P2 > set_union_result< borrowed_iterator_t< Rng1 >, borrowed_iterator_t< Rng2 >, O > | ranges::set_union (Rng1 &&rng1, Rng2 &&rng2, O out, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename Gen = detail::default_random_engine &> | |
requires random_access_iterator< I > &&sentinel_for< S, I > &&permutable< I > &&uniform_random_bit_generator< std::remove_reference_t< Gen > > &&convertible_to< invoke_result_t< Gen & >, iter_difference_t< I > > I | ranges::shuffle (I const first, S const last, Gen &&gen=detail::get_random_engine()) |
function template shuffle | |
template<typename Rng , typename Gen = detail::default_random_engine &> | |
requires random_access_range< Rng > &&permutable< iterator_t< Rng > > &&uniform_random_bit_generator< std::remove_reference_t< Gen > > &&convertible_to< invoke_result_t< Gen & >, iter_difference_t< iterator_t< Rng > > > borrowed_iterator_t< Rng > | ranges::shuffle (Rng &&rng, Gen &&rand=detail::get_random_engine()) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename C = less, typename P = identity> | |
requires sortable< I, C, P > &&random_access_iterator< I > &&sentinel_for< S, I > I | ranges::sort (I first, S end_, C pred=C{}, P proj=P{}) |
function template sort | |
template<typename Rng , typename C = less, typename P = identity> | |
requires sortable< iterator_t< Rng >, C, P > &&random_access_range< Rng > borrowed_iterator_t< Rng > | ranges::sort (Rng &&rng, C pred=C{}, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename C = less, typename P = identity> | |
requires random_access_iterator< I > &&sentinel_for< S, I > &&sortable< I, C, P > I | ranges::sort_heap (I first, S last, C pred=C{}, P proj=P{}) |
template<typename Rng , typename C = less, typename P = identity> | |
requires random_access_range< Rng & > &&sortable< iterator_t< Rng >, C, P > borrowed_iterator_t< Rng > | ranges::sort_heap (Rng &&rng, C pred=C{}, P proj=P{}) |
template<typename I , typename S , typename C , typename P = identity> | |
requires bidirectional_iterator< I > &&sentinel_for< S, I > &&indirect_unary_predicate< C, projected< I, P > > &&permutable< I > I | ranges::stable_partition (I first, S last, C pred, P proj=P{}) |
function template stable_partition | |
template<typename Rng , typename C , typename P = identity> | |
requires bidirectional_range< Rng > &&indirect_unary_predicate< C, projected< iterator_t< Rng >, P > > &&permutable< iterator_t< Rng > > borrowed_iterator_t< Rng > | ranges::stable_partition (Rng &&rng, C pred, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename C = less, typename P = identity> | |
requires sortable< I, C, P > &&random_access_iterator< I > &&sentinel_for< S, I > I | ranges::stable_sort (I first, S end_, C pred=C{}, P proj=P{}) |
function template stable_sort | |
template<typename Rng , typename C = less, typename P = identity> | |
requires sortable< iterator_t< Rng >, C, P > &&random_access_range< Rng > borrowed_iterator_t< Rng > | ranges::stable_sort (Rng &&rng, C pred=C{}, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I1 , typename S1 , typename I2 , typename S2 , typename Comp = equal_to, typename Proj1 = identity, typename Proj2 = identity> | |
requires input_iterator< I1 > &&sentinel_for< S1, I1 > &&input_iterator< I2 > &&sentinel_for< S2, I2 > &&constexpr indirectly_comparable< I1, I2, Comp, Proj1, Proj2 > bool | ranges::starts_with (I1 first1, S1 last1, I2 first2, S2 last2, Comp comp={}, Proj1 proj1={}, Proj2 proj2={}) |
function template starts_with | |
template<typename R1 , typename R2 , typename Comp = equal_to, typename Proj1 = identity, typename Proj2 = identity> | |
requires input_range< R1 > &&input_range< R2 > &&constexpr indirectly_comparable< iterator_t< R1 >, iterator_t< R2 >, Comp, Proj1, Proj2 > bool | ranges::starts_with (R1 &&r1, R2 &&r2, Comp comp={}, Proj1 proj1={}, Proj2 proj2={}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I1 , typename S1 , typename I2 > | |
requires input_iterator< I1 > &&sentinel_for< S1, I1 > &&input_iterator< I2 > &&indirectly_swappable< I1, I2 > swap_ranges_result< I1, I2 > | ranges::swap_ranges (I1 begin1, S1 end1, I2 begin2) |
function template swap_ranges | |
template<typename I1 , typename S1 , typename I2 , typename S2 > | |
requires input_iterator< I1 > &&sentinel_for< S1, I1 > &&input_iterator< I2 > &&sentinel_for< S2, I2 > &&indirectly_swappable< I1, I2 > swap_ranges_result< I1, I2 > | ranges::swap_ranges (I1 begin1, S1 end1, I2 begin2, S2 end2) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename Rng1 , typename I2_ > | |
requires input_range< Rng1 > &&input_iterator< uncvref_t< I2_ > > &&indirectly_swappable< iterator_t< Rng1 >, uncvref_t< I2_ > > swap_ranges_result< iterator_t< Rng1 >, uncvref_t< I2_ > > | ranges::swap_ranges (Rng1 &&rng1, I2_ &&begin2) |
template<typename Rng1 , typename Rng2 > | |
requires input_range< Rng1 > &&input_range< Rng2 > &&indirectly_swappable< iterator_t< Rng1 >, iterator_t< Rng2 > > swap_ranges_result< borrowed_iterator_t< Rng1 >, borrowed_iterator_t< Rng2 > > | ranges::swap_ranges (Rng1 &&rng1, Rng2 &&rng2) |
template<typename I , typename S , typename O , typename F , typename P = identity> | |
requires input_iterator< I > &&sentinel_for< S, I > &&weakly_incrementable< O > &©_constructible< F > &&indirectly_writable< O, indirect_result_t< F &, projected< I, P > > > unary_transform_result< I, O > | ranges::transform (I first, S last, O out, F fun, P proj=P{}) |
function template transform | |
requires input_iterator< I0 > &&sentinel_for< S0, I0 > &&input_iterator< I1 > &&weakly_incrementable< O > &©_constructible< F > &&indirectly_writable< O, indirect_result_t< F &, projected< I0, P0 >, projected< I1, P1 > > > O | ranges::transform (I0 begin0, S0 end0, I1 begin1, O out, F fun, P0 proj0=P0{}, P1 proj1=P1{}) |
template<typename I0 , typename S0 , typename I1 , typename S1 , typename O , typename F , typename P0 = identity, typename P1 = identity> | |
requires input_iterator< I0 > &&sentinel_for< S0, I0 > &&input_iterator< I1 > &&sentinel_for< S1, I1 > &&weakly_incrementable< O > &©_constructible< F > &&indirectly_writable< O, indirect_result_t< F &, projected< I0, P0 >, projected< I1, P1 > > > binary_transform_result< I0, I1, O > | ranges::transform (I0 begin0, S0 end0, I1 begin1, S1 end1, O out, F fun, P0 proj0=P0{}, P1 proj1=P1{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename Rng , typename O , typename F , typename P = identity> | |
requires input_range< Rng > &&weakly_incrementable< O > &©_constructible< F > &&indirectly_writable< O, indirect_result_t< F &, projected< iterator_t< Rng >, P > > > unary_transform_result< borrowed_iterator_t< Rng >, O > | ranges::transform (Rng &&rng, O out, F fun, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
requires input_range< Rng0 > &&input_iterator< uncvref_t< I1Ref > > &&weakly_incrementable< O > &©_constructible< F > &&indirectly_writable< O, indirect_result_t< F &, projected< iterator_t< Rng0 >, P0 >, projected< uncvref_t< I1Ref >, P1 > > > O | ranges::transform (Rng0 &&rng0, I1Ref &&begin1, O out, F fun, P0 proj0=P0{}, P1 proj1=P1{}) |
template<typename Rng0 , typename Rng1 , typename O , typename F , typename P0 = identity, typename P1 = identity> | |
requires input_range< Rng0 > &&input_range< Rng1 > &&weakly_incrementable< O > &©_constructible< F > &&indirectly_writable< O, indirect_result_t< F &, projected< iterator_t< Rng0 >, P0 >, projected< iterator_t< Rng1 >, P1 > > > binary_transform_result< borrowed_iterator_t< Rng0 >, borrowed_iterator_t< Rng1 >, O > | ranges::transform (Rng0 &&rng0, Rng1 &&rng1, O out, F fun, P0 proj0=P0{}, P1 proj1=P1{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename C = equal_to, typename P = identity> | |
requires sortable< I, C, P > &&sentinel_for< S, I > I | ranges::unique (I first, S last, C pred=C{}, P proj=P{}) |
template function unique More... | |
template<typename Rng , typename C = equal_to, typename P = identity> | |
requires sortable< iterator_t< Rng >, C, P > &&range< Rng > borrowed_iterator_t< Rng > | ranges::unique (Rng &&rng, C pred=C{}, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename O , typename C = equal_to, typename P = identity> | |
requires input_iterator< I > &&sentinel_for< S, I > &&indirect_relation< C, projected< I, P > > &&weakly_incrementable< O > &&indirectly_copyable< I, O > &&forward_iterator< I > forward_iterator< O > indirectly_copyable_storable< I, O > unique_copy_result< I, O > | ranges::unique_copy (I first, S last, O out, C pred=C{}, P proj=P{}) |
template function unique_copy More... | |
template<typename Rng , typename O , typename C = equal_to, typename P = identity> | |
requires input_range< Rng > &&indirect_relation< C, projected< iterator_t< Rng >, P > > &&weakly_incrementable< O > &&indirectly_copyable< iterator_t< Rng >, O > &&forward_iterator< iterator_t< Rng > > forward_iterator< O > indirectly_copyable_storable< iterator_t< Rng >, O > unique_copy_result< borrowed_iterator_t< Rng >, O > | ranges::unique_copy (Rng &&rng, O out, C pred=C{}, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename C , typename P = identity> | |
requires bidirectional_iterator< I > &&permutable< I > &&indirect_unary_predicate< C, projected< I, P > > I | ranges::unstable_remove_if (I first, I last, C pred, P proj={}) |
unstable_remove have O(1) complexity for each element remove, unlike remove O(n) [for worst case]. Each erased element overwritten (moved in) with last one. unstable_remove_if does not preserve relative element order. More... | |
template<typename Rng , typename C , typename P = identity> | |
requires bidirectional_range< Rng > &&common_range< Rng > &&permutable< iterator_t< Rng > > &&indirect_unary_predicate< C, projected< iterator_t< Rng >, P > > borrowed_iterator_t< Rng > | ranges::unstable_remove_if (Rng &&rng, C pred, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
template<typename I , typename S , typename V , typename C = less, typename P = identity> | |
requires forward_iterator< I > &&sentinel_for< S, I > &&indirect_strict_weak_order< C, V const *, projected< I, P > > I | ranges::upper_bound (I first, S last, V const &val, C pred=C{}, P proj=P{}) |
function template upper_bound | |
template<typename Rng , typename V , typename C = less, typename P = identity> | |
requires forward_range< Rng > &&indirect_strict_weak_order< C, V const *, projected< iterator_t< Rng >, P > > borrowed_iterator_t< Rng > | ranges::upper_bound (Rng &&rng, V const &val, C pred=C{}, P proj=P{}) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
Variables | |
requires input_iterator< I0 > &&sentinel_for< S0, I0 > &&input_iterator< I1 > &&indirectly_comparable< I0, I1, C, P0, P1 > S0 I1 | ranges::begin1 |
requires forward_iterator< I1 > &&sentinel_for< S1, I1 > &&forward_iterator< I2 > &&indirectly_comparable< I1, I2, C, P1, P2 > S1 I2 | ranges::begin2 |
ranges::C = equal_to | |
requires input_iterator< I0 > &&sentinel_for< S0, I0 > &&input_iterator< I1 > &&indirectly_comparable< I0, I1, C, P0, P1 > S0 | ranges::end0 |
requires forward_iterator< I1 > &&sentinel_for< S1, I1 > &&forward_iterator< I2 > &&indirectly_comparable< I1, I2, C, P1, P2 > S1 | ranges::end1 |
ranges::I1 | |
requires forward_iterator< I1 > &&sentinel_for< S1, I1 > &&forward_iterator< I2 > &&indirectly_comparable< I1, I2, C, P1, P2 > S1 I2 C P1 P2 | ranges::I2 |
ranges::iterator_t< Rng1 > | |
requires forward_range< Rng1 > &&forward_iterator< uncvref_t< I2Ref > > &&indirectly_comparable< iterator_t< Rng1 >, uncvref_t< I2Ref >, C, P1, P2 > I2Ref C P1 P2 | ranges::iterator_t< Rng2 > |
ranges::P0 = identity | |
requires input_iterator< I0 > &&sentinel_for< S0, I0 > &&input_iterator< I1 > &&indirectly_comparable< I0, I1, C, P0, P1 > S0 I1 C P0 P1 | ranges::P1 = identity > requires ` input_iterator<I0> && sentinel_for<S0 |
requires forward_iterator< I1 > &&sentinel_for< S1, I1 > &&forward_iterator< I2 > &&indirectly_comparable< I1, I2, C, P1, P2 > S1 I2 C P1 P2 | ranges::P2 = identity > requires ` forward_iterator<I1> && sentinel_for<S1 |
requires input_iterator< I0 > &&sentinel_for< S0, I0 > &&input_iterator< I1 > &&indirectly_comparable< I0, I1, C, P0, P1 > S0 I1 C | ranges::pred = C{} |
requires input_iterator< I0 > &&sentinel_for< S0, I0 > &&input_iterator< I1 > &&indirectly_comparable< I0, I1, C, P0, P1 > S0 I1 C P0 | ranges::proj0 = P0{} |
requires input_iterator< I0 > &&sentinel_for< S0, I0 > &&input_iterator< I1 > &&indirectly_comparable< I0, I1, C, P0, P1 > S0 I1 C P0 P1 | ranges::proj1 |
requires forward_iterator< I1 > &&sentinel_for< S1, I1 > &&forward_iterator< I2 > &&indirectly_comparable< I1, I2, C, P1, P2 > S1 I2 C P1 P2 | ranges::proj2 |
requires input_range< Rng0 > &&input_iterator< uncvref_t< I1Ref > > &&indirectly_comparable< iterator_t< Rng0 >, uncvref_t< I1Ref >, C, P0, P1 > I1Ref C P0 P1 | ranges::Rng1 |
requires forward_range< Rng1 > &&forward_iterator< uncvref_t< I2Ref > > &&indirectly_comparable< iterator_t< Rng1 >, uncvref_t< I2Ref >, C, P1, P2 > I2Ref C P1 P2 | ranges::Rng2 |
requires input_iterator< I0 > &&sentinel_for< S0, I0 > &&input_iterator< I1 > &&indirectly_comparable< I0, I1, C, P0, P1 > S0 I1 C P0 P1 | ranges::S0 |
requires input_iterator< I0 > &&sentinel_for< S0, I0 > &&input_iterator< I1 > &&indirectly_comparable< I0, I1, C, P0, P1 > S0 I1 C P0 P1 | ranges::S1 |
requires forward_iterator< I1 > &&sentinel_for< S1, I1 > &&forward_iterator< I2 > &&indirectly_comparable< I1, I2, C, P1, P2 > S1 I2 C P1 P2 | ranges::S2 |
requires input_range< Rng0 > &&input_iterator< uncvref_t< I1Ref > > &&weakly_incrementable< O > &©_constructible< F > &&indirectly_writable< O, indirect_result_t< F &, projected< iterator_t< Rng0 >, P0 >, projected< uncvref_t< I1Ref >, P1 > > > | ranges::uncvref_t< I1Ref > |
requires forward_iterator<I>&& sentinel_for<S, I>&& indirect_relation<C, projected<I, P> > I ranges::adjacent_find | ( | I | first, |
S | last, | ||
C | pred = C{} , |
||
P | proj = P{} |
||
) |
#include <range/v3/algorithm/adjacent_find.hpp>
function template adjacent_find
range-based version of the adjacent_find
std algorithm
Rng
is a model of the range
concept C
is a model of the BinaryPredicate
concept requires permutable<I>&& sentinel_for<S, I>&& indirect_relation<Pred, projected<I, Proj> > I ranges::adjacent_remove_if | ( | I | first, |
S | last, | ||
Pred | pred = {} , |
||
Proj | proj = {} |
||
) |
#include <range/v3/algorithm/adjacent_remove_if.hpp>
function adjacent_remove_if
range-based version of the adjacent_remove_if
algorithm
Rng
is a model of the forward_range
concept. Pred
is a model of the BinaryPredicate
concept. References ranges::adjacent_remove_if().
requires forward_iterator<I>&& sentinel_for<S, I>&& indirect_strict_weak_order<C, V const *, projected<I, P> > bool ranges::binary_search | ( | I | first, |
S | last, | ||
V const & | val, | ||
C | pred = C{} , |
||
P | proj = P{} |
||
) |
#include <range/v3/algorithm/binary_search.hpp>
function template binary_search
range-based version of the binary_search
std algorithm
Rng
is a model of the range
concept
|
constexpr |
#include <range/v3/algorithm/find.hpp>
template function find
range-based version of the find
std algorithm
Rng
is a model of the range
concept I
is a model of the input_iterator
concept S
is a model of the sentinel_for<I>
concept P
is a model of the invocable<iter_common_reference_t<I>>
concept P
is equality_comparable with V requires input_iterator<I>&& sentinel_for<S, I>&& indirect_unary_predicate<F, projected<I, P> > I ranges::find_if | ( | I | first, |
S | last, | ||
F | pred, | ||
P | proj = P{} |
||
) |
#include <range/v3/algorithm/find_if.hpp>
template function find
range-based version of the find
std algorithm
Rng
is a model of the range
concept I
is a model of the input_iterator
concept S
is a model of the sentinel_for<I>
concept P
is a model of the invocable<V>
concept, where V
is the value type of I. F
models predicate<X>
, where X
is the result type of invocable<P, V>
requires input_iterator<I>&& sentinel_for<S, I>&& indirect_unary_predicate<F, projected<I, P> > I ranges::find_if_not | ( | I | first, |
S | last, | ||
F | pred, | ||
P | proj = P{} |
||
) |
#include <range/v3/algorithm/find_if_not.hpp>
template function find_if_not
range-based version of the find_if_not
std algorithm
Rng
is a model of the range
concept I
is a model of the input_iterator
concept S
is a model of the sentinel_for<I>
concept P
is a model of the invocable<V>
concept, where V
is the value type of I. F
models predicate<X>
, where X
is the result type of invocable<P, V>
requires forward_iterator<I>&& sentinel_for<S, I>&& indirect_strict_weak_order<R, projected<I, P> > bool ranges::is_sorted | ( | I | first, |
S | last, | ||
R | rel = R{} , |
||
P | proj = P{} |
||
) |
#include <range/v3/algorithm/is_sorted.hpp>
template function is_sorted
range-based version of the is_sorted
std algorithm
Works on forward_ranges
Rng
is a model of the forward_range
concept I
is a model of the forward_iterator
concept S
and I
model the sentinel_for<S, I>
concept R
and projected<I, P>
model the indirect_strict_weak_order<R, projected<I, P>>
concept requires forward_iterator<I>&& sentinel_for<S, I>&& indirect_strict_weak_order<R, projected<I, P> > I ranges::is_sorted_until | ( | I | first, |
S | last, | ||
R | pred = R{} , |
||
P | proj = P{} |
||
) |
#include <range/v3/algorithm/is_sorted_until.hpp>
template function is_sorted_until
range-based version of the is_sorted_until
std algorithm
Works on forward_ranges
Rng
is a model of the forward_range
concept I
is a model of the forward_iterator
concept S
and I
model the sentinel_for<S, I>
concept R
and projected<I, P>
model the indirect_strict_weak_order<R, projected<I, P>>
concept requires sortable<I, C, P>&& sentinel_for<S, I> I ranges::unique | ( | I | first, |
S | last, | ||
C | pred = C{} , |
||
P | proj = P{} |
||
) |
#include <range/v3/algorithm/unique.hpp>
template function unique
range-based version of the unique
std algorithm
Rng
is a model of the forward_range
concept I
is a model of the forward_iterator
concept S
is a model of the sentinel_for
concept C
is a model of the relation
concept requires input_iterator<I>&& sentinel_for<S, I>&& indirect_relation<C, projected<I, P> >&& weakly_incrementable<O>&& indirectly_copyable<I, O>&& forward_iterator<I> forward_iterator<O> indirectly_copyable_storable<I, O> unique_copy_result<I, O> ranges::unique_copy | ( | I | first, |
S | last, | ||
O | out, | ||
C | pred = C{} , |
||
P | proj = P{} |
||
) |
#include <range/v3/algorithm/unique_copy.hpp>
template function unique_copy
range-based version of the unique_copy
std algorithm
Rng
is a model of the input_range
concept O
is a model of the weakly_incrementable
concept C
is a model of the relation
concept requires bidirectional_iterator<I>&& permutable<I>&& indirect_unary_predicate<C, projected<I, P> > I ranges::unstable_remove_if | ( | I | first, |
I | last, | ||
C | pred, | ||
P | proj = {} |
||
) |
#include <range/v3/algorithm/unstable_remove_if.hpp>
unstable_remove have O(1) complexity for each element remove, unlike remove O(n) [for worst case]. Each erased element overwritten (moved in) with last one. unstable_remove_if does not preserve relative element order.
function template unstable_remove_if
requires forward_range< Rng1 > &&forward_iterator< uncvref_t< I2Ref > > &&indirectly_comparable< iterator_t< Rng1 >, uncvref_t< I2Ref >, C, P1, P2 > I2Ref C P1 ranges::proj1 |
#include <range/v3/algorithm/equal.hpp>