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