[alg.nonmodifying] (original) (raw)

26 Algorithms library [algorithms]

26.6 Non-modifying sequence operations [alg.nonmodifying]

26.6.1 All of [alg.all.of]

template<class InputIterator, class Predicate> constexpr bool all_of(InputIterator first, InputIterator last, Predicate pred);template<class ExecutionPolicy, class ForwardIterator, class Predicate> bool all_of(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last, Predicate pred);template<[input_iterator](iterator.concept.input#concept:input%5Fiterator "24.3.4.9 Concept input_­iterator [iterator.concept.input]") I, [sentinel_for](iterator.concept.sentinel#concept:sentinel%5Ffor "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<I> S, class Proj = identity,[indirect_unary_predicate](indirectcallable.indirectinvocable#concept:indirect%5Funary%5Fpredicate "24.3.6.3 Indirect callables [indirectcallable.indirectinvocable]")<projected<I, Proj>> Pred> constexpr bool ranges::all_of(I first, S last, Pred pred, Proj proj = {});template<[input_range](range.refinements#concept:input%5Frange "25.4.5 Other range refinements [range.refinements]") R, class Proj = identity,[indirect_unary_predicate](indirectcallable.indirectinvocable#concept:indirect%5Funary%5Fpredicate "24.3.6.3 Indirect callables [indirectcallable.indirectinvocable]")<projected<iterator_t<R>, Proj>> Pred> constexpr bool ranges::all_of(R&& r, Pred pred, Proj proj = {});

Let E be:

Returns: false if E is falsefor some iterator i in the range [first, last), andtrue otherwise.

Complexity: At most last - first applications of the predicate and any projection.

26.6.2 Any of [alg.any.of]

template<class InputIterator, class Predicate> constexpr bool any_of(InputIterator first, InputIterator last, Predicate pred);template<class ExecutionPolicy, class ForwardIterator, class Predicate> bool any_of(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last, Predicate pred);template<[input_iterator](iterator.concept.input#concept:input%5Fiterator "24.3.4.9 Concept input_­iterator [iterator.concept.input]") I, [sentinel_for](iterator.concept.sentinel#concept:sentinel%5Ffor "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<I> S, class Proj = identity,[indirect_unary_predicate](indirectcallable.indirectinvocable#concept:indirect%5Funary%5Fpredicate "24.3.6.3 Indirect callables [indirectcallable.indirectinvocable]")<projected<I, Proj>> Pred> constexpr bool ranges::any_of(I first, S last, Pred pred, Proj proj = {});template<[input_range](range.refinements#concept:input%5Frange "25.4.5 Other range refinements [range.refinements]") R, class Proj = identity,[indirect_unary_predicate](indirectcallable.indirectinvocable#concept:indirect%5Funary%5Fpredicate "24.3.6.3 Indirect callables [indirectcallable.indirectinvocable]")<projected<iterator_t<R>, Proj>> Pred> constexpr bool ranges::any_of(R&& r, Pred pred, Proj proj = {});

Let E be:

Returns: true if E is true for some iterator iin the range [first, last), and false otherwise.

Complexity: At most last - first applications of the predicate and any projection.

26.6.3 None of [alg.none.of]

template<class InputIterator, class Predicate> constexpr bool none_of(InputIterator first, InputIterator last, Predicate pred);template<class ExecutionPolicy, class ForwardIterator, class Predicate> bool none_of(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last, Predicate pred);template<[input_iterator](iterator.concept.input#concept:input%5Fiterator "24.3.4.9 Concept input_­iterator [iterator.concept.input]") I, [sentinel_for](iterator.concept.sentinel#concept:sentinel%5Ffor "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<I> S, class Proj = identity,[indirect_unary_predicate](indirectcallable.indirectinvocable#concept:indirect%5Funary%5Fpredicate "24.3.6.3 Indirect callables [indirectcallable.indirectinvocable]")<projected<I, Proj>> Pred> constexpr bool ranges::none_of(I first, S last, Pred pred, Proj proj = {});template<[input_range](range.refinements#concept:input%5Frange "25.4.5 Other range refinements [range.refinements]") R, class Proj = identity,[indirect_unary_predicate](indirectcallable.indirectinvocable#concept:indirect%5Funary%5Fpredicate "24.3.6.3 Indirect callables [indirectcallable.indirectinvocable]")<projected<iterator_t<R>, Proj>> Pred> constexpr bool ranges::none_of(R&& r, Pred pred, Proj proj = {});

Let E be:

Returns: false if E is truefor some iterator i in the range [first, last), andtrue otherwise.

Complexity: At most last - first applications of the predicate and any projection.

26.6.4 Contains [alg.contains]

template<[input_iterator](iterator.concept.input#concept:input%5Fiterator "24.3.4.9 Concept input_­iterator [iterator.concept.input]") I, [sentinel_for](iterator.concept.sentinel#concept:sentinel%5Ffor "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<I> S, class Proj = identity,class T = projected_value_t<I, Proj>> requires [indirect_binary_predicate](indirectcallable.indirectinvocable#concept:indirect%5Fbinary%5Fpredicate "24.3.6.3 Indirect callables [indirectcallable.indirectinvocable]")<ranges::equal_to, projected<I, Proj>, const T*> constexpr bool ranges::contains(I first, S last, const T& value, Proj proj = {});template<[input_range](range.refinements#concept:input%5Frange "25.4.5 Other range refinements [range.refinements]") R, class Proj = identity, class T = projected_value_t<iterator_t<R>, Proj>> requires [indirect_binary_predicate](indirectcallable.indirectinvocable#concept:indirect%5Fbinary%5Fpredicate "24.3.6.3 Indirect callables [indirectcallable.indirectinvocable]")<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*> constexpr bool ranges::contains(R&& r, const T& value, Proj proj = {});

Returns: ranges​::​find(std​::​move(first), last, value, proj) != last.

template<[forward_iterator](iterator.concept.forward#concept:forward%5Fiterator "24.3.4.11 Concept forward_­iterator [iterator.concept.forward]") I1, [sentinel_for](iterator.concept.sentinel#concept:sentinel%5Ffor "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<I1> S1,[forward_iterator](iterator.concept.forward#concept:forward%5Fiterator "24.3.4.11 Concept forward_­iterator [iterator.concept.forward]") I2, [sentinel_for](iterator.concept.sentinel#concept:sentinel%5Ffor "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<I2> S2,class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity> requires [indirectly_comparable](alg.req.ind.cmp#concept:indirectly%5Fcomparable "24.3.7.5 Concept indirectly_­comparable [alg.req.ind.cmp]")<I1, I2, Pred, Proj1, Proj2> constexpr bool ranges::contains_subrange(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {});template<[forward_range](range.refinements#concept:forward%5Frange "25.4.5 Other range refinements [range.refinements]") R1, [forward_range](range.refinements#concept:forward%5Frange "25.4.5 Other range refinements [range.refinements]") R2,class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity> requires [indirectly_comparable](alg.req.ind.cmp#concept:indirectly%5Fcomparable "24.3.7.5 Concept indirectly_­comparable [alg.req.ind.cmp]")<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2> constexpr bool ranges::contains_subrange(R1&& r1, R2&& r2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {});

Returns: first2 == last2 || !ranges​::​search(first1, last1, first2, last2, pred, proj1, proj2).empty().

26.6.5 For each [alg.foreach]

template<class InputIterator, class Function> constexpr Function for_each(InputIterator first, InputIterator last, Function f);

Effects: Applies f to the result of dereferencing every iterator in the range [first, last), starting from first and proceeding to last - 1.

[Note 2:

If the type of first meets the requirements of a mutable iterator,f can apply non-constant functions through the dereferenced iterator.

— _end note_]

Complexity: Applies f exactly last - first times.

Remarks: If f returns a result, the result is ignored.

template<class ExecutionPolicy, class ForwardIterator, class Function> void for_each(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last, Function f);

Effects: Applies f to the result of dereferencing every iterator in the range [first, last).

[Note 3:

If the type of first meets the requirements of a mutable iterator,f can apply non-constant functions through the dereferenced iterator.

— _end note_]

Complexity: Applies f exactly last - first times.

Remarks: If f returns a result, the result is ignored.

Implementations do not have the freedom granted under [algorithms.parallel.exec]to make arbitrary copies of elements from the input sequence.

[Note 4:

Does not return a copy of its Function parameter, since parallelization often does not permit efficient state accumulation.

— _end note_]

template<[input_iterator](iterator.concept.input#concept:input%5Fiterator "24.3.4.9 Concept input_­iterator [iterator.concept.input]") I, [sentinel_for](iterator.concept.sentinel#concept:sentinel%5Ffor "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<I> S, class Proj = identity,[indirectly_unary_invocable](indirectcallable.indirectinvocable#concept:indirectly%5Funary%5Finvocable "24.3.6.3 Indirect callables [indirectcallable.indirectinvocable]")<projected<I, Proj>> Fun> constexpr ranges::for_each_result<I, Fun> ranges::for_each(I first, S last, Fun f, Proj proj = {});template<[input_range](range.refinements#concept:input%5Frange "25.4.5 Other range refinements [range.refinements]") R, class Proj = identity,[indirectly_unary_invocable](indirectcallable.indirectinvocable#concept:indirectly%5Funary%5Finvocable "24.3.6.3 Indirect callables [indirectcallable.indirectinvocable]")<projected<iterator_t<R>, Proj>> Fun> constexpr ranges::for_each_result<borrowed_iterator_t<R>, Fun> ranges::for_each(R&& r, Fun f, Proj proj = {});

Effects: Calls invoke(f, invoke(proj, *i))for every iterator i in the range [first, last), starting from first and proceeding to last - 1.

[Note 5:

If the result of invoke(proj, *i) is a mutable reference,f can apply non-constant functions.

— _end note_]

Returns: {last, std​::​move(f)}.

Complexity: Applies f and proj exactly last - first times.

Remarks: If f returns a result, the result is ignored.

[Note 6:

The overloads in namespace ranges requireFun to model copy_constructible.

— _end note_]

template<class InputIterator, class Size, class Function> constexpr InputIterator for_each_n(InputIterator first, Size n, Function f);

Preconditions: n >= 0 is true.

Effects: Applies f to the result of dereferencing every iterator in the range [first, first + n) in order.

[Note 8:

If the type of first meets the requirements of a mutable iterator,f can apply non-constant functions through the dereferenced iterator.

— _end note_]

Remarks: If f returns a result, the result is ignored.

template<class ExecutionPolicy, class ForwardIterator, class Size, class Function> ForwardIterator for_each_n(ExecutionPolicy&& exec, ForwardIterator first, Size n, Function f);

Preconditions: n >= 0 is true.

Effects: Applies f to the result of dereferencing every iterator in the range [first, first + n).

[Note 9:

If the type of first meets the requirements of a mutable iterator,f can apply non-constant functions through the dereferenced iterator.

— _end note_]

Remarks: If f returns a result, the result is ignored.

Implementations do not have the freedom granted under [algorithms.parallel.exec]to make arbitrary copies of elements from the input sequence.

template<[input_iterator](iterator.concept.input#concept:input%5Fiterator "24.3.4.9 Concept input_­iterator [iterator.concept.input]") I, class Proj = identity,[indirectly_unary_invocable](indirectcallable.indirectinvocable#concept:indirectly%5Funary%5Finvocable "24.3.6.3 Indirect callables [indirectcallable.indirectinvocable]")<projected<I, Proj>> Fun> constexpr ranges::for_each_n_result<I, Fun> ranges::for_each_n(I first, iter_difference_t<I> n, Fun f, Proj proj = {});

Preconditions: n >= 0 is true.

Effects: Calls invoke(f, invoke(proj, *i))for every iterator i in the range [first, first + n) in order.

[Note 10:

If the result of invoke(proj, *i) is a mutable reference,f can apply non-constant functions.

— _end note_]

Returns: {first + n, std​::​move(f)}.

Remarks: If f returns a result, the result is ignored.

[Note 11:

The overload in namespace rangesrequires Fun to model copy_constructible.

— _end note_]

26.6.6 Find [alg.find]

template<class InputIterator, class T = iterator_traits<InputIterator>::value_type> constexpr InputIterator find(InputIterator first, InputIterator last,const T& value);template<class ExecutionPolicy, class ForwardIterator,class T = iterator_traits<ForwardIterator>::value_type> ForwardIterator find(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last,const T& value);template<class InputIterator, class Predicate> constexpr InputIterator find_if(InputIterator first, InputIterator last, Predicate pred);template<class ExecutionPolicy, class ForwardIterator, class Predicate> ForwardIterator find_if(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last, Predicate pred);template<class InputIterator, class Predicate> constexpr InputIterator find_if_not(InputIterator first, InputIterator last, Predicate pred);template<class ExecutionPolicy, class ForwardIterator, class Predicate> ForwardIterator find_if_not(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last, Predicate pred);template<[input_iterator](iterator.concept.input#concept:input%5Fiterator "24.3.4.9 Concept input_­iterator [iterator.concept.input]") I, [sentinel_for](iterator.concept.sentinel#concept:sentinel%5Ffor "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<I> S, class Proj = identity,class T = projected_value_t<I, Proj>> requires [indirect_binary_predicate](indirectcallable.indirectinvocable#concept:indirect%5Fbinary%5Fpredicate "24.3.6.3 Indirect callables [indirectcallable.indirectinvocable]")<ranges::equal_to, projected<I, Proj>, const T*> constexpr I ranges::find(I first, S last, const T& value, Proj proj = {});template<[input_range](range.refinements#concept:input%5Frange "25.4.5 Other range refinements [range.refinements]") R, class Proj = identity, class T = projected_value_t<iterator_t<R>, Proj>> requires [indirect_binary_predicate](indirectcallable.indirectinvocable#concept:indirect%5Fbinary%5Fpredicate "24.3.6.3 Indirect callables [indirectcallable.indirectinvocable]")<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*> constexpr borrowed_iterator_t<R> ranges::find(R&& r, const T& value, Proj proj = {});template<[input_iterator](iterator.concept.input#concept:input%5Fiterator "24.3.4.9 Concept input_­iterator [iterator.concept.input]") I, [sentinel_for](iterator.concept.sentinel#concept:sentinel%5Ffor "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<I> S, class Proj = identity,[indirect_unary_predicate](indirectcallable.indirectinvocable#concept:indirect%5Funary%5Fpredicate "24.3.6.3 Indirect callables [indirectcallable.indirectinvocable]")<projected<I, Proj>> Pred> constexpr I ranges::find_if(I first, S last, Pred pred, Proj proj = {});template<[input_range](range.refinements#concept:input%5Frange "25.4.5 Other range refinements [range.refinements]") R, class Proj = identity,[indirect_unary_predicate](indirectcallable.indirectinvocable#concept:indirect%5Funary%5Fpredicate "24.3.6.3 Indirect callables [indirectcallable.indirectinvocable]")<projected<iterator_t<R>, Proj>> Pred> constexpr borrowed_iterator_t<R> ranges::find_if(R&& r, Pred pred, Proj proj = {});template<[input_iterator](iterator.concept.input#concept:input%5Fiterator "24.3.4.9 Concept input_­iterator [iterator.concept.input]") I, [sentinel_for](iterator.concept.sentinel#concept:sentinel%5Ffor "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<I> S, class Proj = identity,[indirect_unary_predicate](indirectcallable.indirectinvocable#concept:indirect%5Funary%5Fpredicate "24.3.6.3 Indirect callables [indirectcallable.indirectinvocable]")<projected<I, Proj>> Pred> constexpr I ranges::find_if_not(I first, S last, Pred pred, Proj proj = {});template<[input_range](range.refinements#concept:input%5Frange "25.4.5 Other range refinements [range.refinements]") R, class Proj = identity,[indirect_unary_predicate](indirectcallable.indirectinvocable#concept:indirect%5Funary%5Fpredicate "24.3.6.3 Indirect callables [indirectcallable.indirectinvocable]")<projected<iterator_t<R>, Proj>> Pred> constexpr borrowed_iterator_t<R> ranges::find_if_not(R&& r, Pred pred, Proj proj = {});

Let E be:

Returns: The first iterator i in the range [first, last) for which E is true.

Returns last if no such iterator is found.

Complexity: At most last - first applications of the corresponding predicate and any projection.

26.6.7 Find last [alg.find.last]

template<[forward_iterator](iterator.concept.forward#concept:forward%5Fiterator "24.3.4.11 Concept forward_­iterator [iterator.concept.forward]") I, [sentinel_for](iterator.concept.sentinel#concept:sentinel%5Ffor "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<I> S, class Proj = identity,class T = projected_value_t<I, Proj>> requires [indirect_binary_predicate](indirectcallable.indirectinvocable#concept:indirect%5Fbinary%5Fpredicate "24.3.6.3 Indirect callables [indirectcallable.indirectinvocable]")<ranges::equal_to, projected<I, Proj>, const T*> constexpr subrange<I> ranges::find_last(I first, S last, const T& value, Proj proj = {});template<[forward_range](range.refinements#concept:forward%5Frange "25.4.5 Other range refinements [range.refinements]") R, class Proj = identity,class T = projected_value_t<iterator_t<R>, Proj>> requires [indirect_binary_predicate](indirectcallable.indirectinvocable#concept:indirect%5Fbinary%5Fpredicate "24.3.6.3 Indirect callables [indirectcallable.indirectinvocable]")<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*> constexpr borrowed_subrange_t<R> ranges::find_last(R&& r, const T& value, Proj proj = {});template<[forward_iterator](iterator.concept.forward#concept:forward%5Fiterator "24.3.4.11 Concept forward_­iterator [iterator.concept.forward]") I, [sentinel_for](iterator.concept.sentinel#concept:sentinel%5Ffor "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<I> S, class Proj = identity,[indirect_unary_predicate](indirectcallable.indirectinvocable#concept:indirect%5Funary%5Fpredicate "24.3.6.3 Indirect callables [indirectcallable.indirectinvocable]")<projected<I, Proj>> Pred> constexpr subrange<I> ranges::find_last_if(I first, S last, Pred pred, Proj proj = {});template<[forward_range](range.refinements#concept:forward%5Frange "25.4.5 Other range refinements [range.refinements]") R, class Proj = identity,[indirect_unary_predicate](indirectcallable.indirectinvocable#concept:indirect%5Funary%5Fpredicate "24.3.6.3 Indirect callables [indirectcallable.indirectinvocable]")<projected<iterator_t<R>, Proj>> Pred> constexpr borrowed_subrange_t<R> ranges::find_last_if(R&& r, Pred pred, Proj proj = {});template<[forward_iterator](iterator.concept.forward#concept:forward%5Fiterator "24.3.4.11 Concept forward_­iterator [iterator.concept.forward]") I, [sentinel_for](iterator.concept.sentinel#concept:sentinel%5Ffor "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<I> S, class Proj = identity,[indirect_unary_predicate](indirectcallable.indirectinvocable#concept:indirect%5Funary%5Fpredicate "24.3.6.3 Indirect callables [indirectcallable.indirectinvocable]")<projected<I, Proj>> Pred> constexpr subrange<I> ranges::find_last_if_not(I first, S last, Pred pred, Proj proj = {});template<[forward_range](range.refinements#concept:forward%5Frange "25.4.5 Other range refinements [range.refinements]") R, class Proj = identity,[indirect_unary_predicate](indirectcallable.indirectinvocable#concept:indirect%5Funary%5Fpredicate "24.3.6.3 Indirect callables [indirectcallable.indirectinvocable]")<projected<iterator_t<R>, Proj>> Pred> constexpr borrowed_subrange_t<R> ranges::find_last_if_not(R&& r, Pred pred, Proj proj = {});

Let E be:

Returns: Let i be the last iterator in the range [first, last) for which E is true.

Returns {i, last}, or{last, last} if no such iterator is found.

Complexity: At most last - first applications of the corresponding predicate and projection.

26.6.8 Find end [alg.find.end]

template<class ForwardIterator1, class ForwardIterator2> constexpr ForwardIterator1 find_end(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2);template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2> ForwardIterator1 find_end(ExecutionPolicy&& exec, ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2);template<class ForwardIterator1, class ForwardIterator2,class BinaryPredicate> constexpr ForwardIterator1 find_end(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred);template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,class BinaryPredicate> ForwardIterator1 find_end(ExecutionPolicy&& exec, ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred);template<[forward_iterator](iterator.concept.forward#concept:forward%5Fiterator "24.3.4.11 Concept forward_­iterator [iterator.concept.forward]") I1, [sentinel_for](iterator.concept.sentinel#concept:sentinel%5Ffor "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<I1> S1, [forward_iterator](iterator.concept.forward#concept:forward%5Fiterator "24.3.4.11 Concept forward_­iterator [iterator.concept.forward]") I2, [sentinel_for](iterator.concept.sentinel#concept:sentinel%5Ffor "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<I2> S2,class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity> requires [indirectly_comparable](alg.req.ind.cmp#concept:indirectly%5Fcomparable "24.3.7.5 Concept indirectly_­comparable [alg.req.ind.cmp]")<I1, I2, Pred, Proj1, Proj2> constexpr subrange<I1> ranges::find_end(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {});template<[forward_range](range.refinements#concept:forward%5Frange "25.4.5 Other range refinements [range.refinements]") R1, [forward_range](range.refinements#concept:forward%5Frange "25.4.5 Other range refinements [range.refinements]") R2,class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity> requires [indirectly_comparable](alg.req.ind.cmp#concept:indirectly%5Fcomparable "24.3.7.5 Concept indirectly_­comparable [alg.req.ind.cmp]")<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2> constexpr borrowed_subrange_t<R1> ranges::find_end(R1&& r1, R2&& r2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {});

Let:

Returns:

Complexity: At most(last2 - first2) * (last1 - first1 - (last2 - first2) + 1)applications of the corresponding predicate and any projections.

26.6.9 Find first [alg.find.first.of]

template<class InputIterator, class ForwardIterator> constexpr InputIterator find_first_of(InputIterator first1, InputIterator last1, ForwardIterator first2, ForwardIterator last2);template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2> ForwardIterator1 find_first_of(ExecutionPolicy&& exec, ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2);template<class InputIterator, class ForwardIterator,class BinaryPredicate> constexpr InputIterator find_first_of(InputIterator first1, InputIterator last1, ForwardIterator first2, ForwardIterator last2, BinaryPredicate pred);template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,class BinaryPredicate> ForwardIterator1 find_first_of(ExecutionPolicy&& exec, ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred);template<[input_iterator](iterator.concept.input#concept:input%5Fiterator "24.3.4.9 Concept input_­iterator [iterator.concept.input]") I1, [sentinel_for](iterator.concept.sentinel#concept:sentinel%5Ffor "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<I1> S1, [forward_iterator](iterator.concept.forward#concept:forward%5Fiterator "24.3.4.11 Concept forward_­iterator [iterator.concept.forward]") I2, [sentinel_for](iterator.concept.sentinel#concept:sentinel%5Ffor "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<I2> S2,class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity> requires [indirectly_comparable](alg.req.ind.cmp#concept:indirectly%5Fcomparable "24.3.7.5 Concept indirectly_­comparable [alg.req.ind.cmp]")<I1, I2, Pred, Proj1, Proj2> constexpr I1 ranges::find_first_of(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {});template<[input_range](range.refinements#concept:input%5Frange "25.4.5 Other range refinements [range.refinements]") R1, [forward_range](range.refinements#concept:forward%5Frange "25.4.5 Other range refinements [range.refinements]") R2,class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity> requires [indirectly_comparable](alg.req.ind.cmp#concept:indirectly%5Fcomparable "24.3.7.5 Concept indirectly_­comparable [alg.req.ind.cmp]")<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2> constexpr borrowed_iterator_t<R1> ranges::find_first_of(R1&& r1, R2&& r2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {});

Let E be:

Effects: Finds an element that matches one of a set of values.

Returns: The first iterator i in the range [first1, last1) such that for some iterator j in the range [first2, last2)E holds.

Returns last1if [first2, last2) is empty or if no such iterator is found.

Complexity: At most (last1 - first1) * (last2 - first2) applications of the corresponding predicate and any projections.

26.6.10 Adjacent find [alg.adjacent.find]

template<class ForwardIterator> constexpr ForwardIterator adjacent_find(ForwardIterator first, ForwardIterator last);template<class ExecutionPolicy, class ForwardIterator> ForwardIterator adjacent_find(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last);template<class ForwardIterator, class BinaryPredicate> constexpr ForwardIterator adjacent_find(ForwardIterator first, ForwardIterator last, BinaryPredicate pred);template<class ExecutionPolicy, class ForwardIterator, class BinaryPredicate> ForwardIterator adjacent_find(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last, BinaryPredicate pred);template<[forward_iterator](iterator.concept.forward#concept:forward%5Fiterator "24.3.4.11 Concept forward_­iterator [iterator.concept.forward]") I, [sentinel_for](iterator.concept.sentinel#concept:sentinel%5Ffor "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<I> S, class Proj = identity,[indirect_binary_predicate](indirectcallable.indirectinvocable#concept:indirect%5Fbinary%5Fpredicate "24.3.6.3 Indirect callables [indirectcallable.indirectinvocable]")<projected<I, Proj>, projected<I, Proj>> Pred = ranges::equal_to> constexpr I ranges::adjacent_find(I first, S last, Pred pred = {}, Proj proj = {});template<[forward_range](range.refinements#concept:forward%5Frange "25.4.5 Other range refinements [range.refinements]") R, class Proj = identity,[indirect_binary_predicate](indirectcallable.indirectinvocable#concept:indirect%5Fbinary%5Fpredicate "24.3.6.3 Indirect callables [indirectcallable.indirectinvocable]")<projected<iterator_t<R>, Proj>, projected<iterator_t<R>, Proj>> Pred = ranges::equal_to> constexpr borrowed_iterator_t<R> ranges::adjacent_find(R&& r, Pred pred = {}, Proj proj = {});

Let E be:

Returns: The first iterator isuch that both i and i + 1 are in the range [first, last) for which E holds.

Returns last if no such iterator is found.

Complexity: For the overloads with no ExecutionPolicy, exactly min((i - first) + 1, (last - first) - 1) applications of the corresponding predicate, where i is adjacent_find's return value.

For the overloads with an ExecutionPolicy, applications of the corresponding predicate, and no more than twice as many applications of any projection.

26.6.11 Count [alg.count]

template<class InputIterator, class T = iterator_traits<InputIterator>::value_type> constexpr typename iterator_traits<InputIterator>::difference_type count(InputIterator first, InputIterator last, const T& value);template<class ExecutionPolicy, class ForwardIterator,class T = iterator_traits<ForwardIterator>::value_type> typename iterator_traits<ForwardIterator>::difference_type count(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last, const T& value);template<class InputIterator, class Predicate> constexpr typename iterator_traits<InputIterator>::difference_type count_if(InputIterator first, InputIterator last, Predicate pred);template<class ExecutionPolicy, class ForwardIterator, class Predicate> typename iterator_traits<ForwardIterator>::difference_type count_if(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last, Predicate pred);template<[input_iterator](iterator.concept.input#concept:input%5Fiterator "24.3.4.9 Concept input_­iterator [iterator.concept.input]") I, [sentinel_for](iterator.concept.sentinel#concept:sentinel%5Ffor "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<I> S, class Proj = identity,class T = projected_value_t<I, Proj>> requires [indirect_binary_predicate](indirectcallable.indirectinvocable#concept:indirect%5Fbinary%5Fpredicate "24.3.6.3 Indirect callables [indirectcallable.indirectinvocable]")<ranges::equal_to, projected<I, Proj>, const T*> constexpr iter_difference_t<I> ranges::count(I first, S last, const T& value, Proj proj = {});template<[input_range](range.refinements#concept:input%5Frange "25.4.5 Other range refinements [range.refinements]") R, class Proj = identity, class T = projected_value_t<iterator_t<R>, Proj>> requires [indirect_binary_predicate](indirectcallable.indirectinvocable#concept:indirect%5Fbinary%5Fpredicate "24.3.6.3 Indirect callables [indirectcallable.indirectinvocable]")<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*> constexpr range_difference_t<R> ranges::count(R&& r, const T& value, Proj proj = {});template<[input_iterator](iterator.concept.input#concept:input%5Fiterator "24.3.4.9 Concept input_­iterator [iterator.concept.input]") I, [sentinel_for](iterator.concept.sentinel#concept:sentinel%5Ffor "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<I> S, class Proj = identity,[indirect_unary_predicate](indirectcallable.indirectinvocable#concept:indirect%5Funary%5Fpredicate "24.3.6.3 Indirect callables [indirectcallable.indirectinvocable]")<projected<I, Proj>> Pred> constexpr iter_difference_t<I> ranges::count_if(I first, S last, Pred pred, Proj proj = {});template<[input_range](range.refinements#concept:input%5Frange "25.4.5 Other range refinements [range.refinements]") R, class Proj = identity,[indirect_unary_predicate](indirectcallable.indirectinvocable#concept:indirect%5Funary%5Fpredicate "24.3.6.3 Indirect callables [indirectcallable.indirectinvocable]")<projected<iterator_t<R>, Proj>> Pred> constexpr range_difference_t<R> ranges::count_if(R&& r, Pred pred, Proj proj = {});

Let E be:

Effects: Returns the number of iterators i in the range [first, last) for which E holds.

Complexity: Exactly last - first applications of the corresponding predicate and any projection.

26.6.12 Mismatch [alg.mismatch]

template<class InputIterator1, class InputIterator2> constexpr pair<InputIterator1, InputIterator2> mismatch(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2);template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2> pair<ForwardIterator1, ForwardIterator2> mismatch(ExecutionPolicy&& exec, ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2);template<class InputIterator1, class InputIterator2,class BinaryPredicate> constexpr pair<InputIterator1, InputIterator2> mismatch(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, BinaryPredicate pred);template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,class BinaryPredicate> pair<ForwardIterator1, ForwardIterator2> mismatch(ExecutionPolicy&& exec, ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, BinaryPredicate pred);template<class InputIterator1, class InputIterator2> constexpr pair<InputIterator1, InputIterator2> mismatch(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2);template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2> pair<ForwardIterator1, ForwardIterator2> mismatch(ExecutionPolicy&& exec, ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2);template<class InputIterator1, class InputIterator2,class BinaryPredicate> constexpr pair<InputIterator1, InputIterator2> mismatch(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, BinaryPredicate pred);template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,class BinaryPredicate> pair<ForwardIterator1, ForwardIterator2> mismatch(ExecutionPolicy&& exec, ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred);template<[input_iterator](iterator.concept.input#concept:input%5Fiterator "24.3.4.9 Concept input_­iterator [iterator.concept.input]") I1, [sentinel_for](iterator.concept.sentinel#concept:sentinel%5Ffor "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<I1> S1, [input_iterator](iterator.concept.input#concept:input%5Fiterator "24.3.4.9 Concept input_­iterator [iterator.concept.input]") I2, [sentinel_for](iterator.concept.sentinel#concept:sentinel%5Ffor "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<I2> S2,class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity> requires [indirectly_comparable](alg.req.ind.cmp#concept:indirectly%5Fcomparable "24.3.7.5 Concept indirectly_­comparable [alg.req.ind.cmp]")<I1, I2, Pred, Proj1, Proj2> constexpr ranges::mismatch_result<I1, I2> ranges::mismatch(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {});template<[input_range](range.refinements#concept:input%5Frange "25.4.5 Other range refinements [range.refinements]") R1, [input_range](range.refinements#concept:input%5Frange "25.4.5 Other range refinements [range.refinements]") R2,class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity> requires [indirectly_comparable](alg.req.ind.cmp#concept:indirectly%5Fcomparable "24.3.7.5 Concept indirectly_­comparable [alg.req.ind.cmp]")<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2> constexpr ranges::mismatch_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>> ranges::mismatch(R1&& r1, R2&& r2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {});

Let last2 be first2 + (last1 - first1)for the overloads with no parameter last2 or r2.

Let E be:

Let N be min(last1 - first1, last2 - first2).

Returns: { first1 + n, first2 + n }, where n is the smallest integer in [0, N) such that E holds, or N if no such integer exists.

Complexity: At most N applications of the corresponding predicate and any projections.

26.6.13 Equal [alg.equal]

template<class InputIterator1, class InputIterator2> constexpr bool equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2);template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2> bool equal(ExecutionPolicy&& exec, ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2);template<class InputIterator1, class InputIterator2,class BinaryPredicate> constexpr bool equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, BinaryPredicate pred);template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,class BinaryPredicate> bool equal(ExecutionPolicy&& exec, ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, BinaryPredicate pred);template<class InputIterator1, class InputIterator2> constexpr bool equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2);template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2> bool equal(ExecutionPolicy&& exec, ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2);template<class InputIterator1, class InputIterator2,class BinaryPredicate> constexpr bool equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, BinaryPredicate pred);template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,class BinaryPredicate> bool equal(ExecutionPolicy&& exec, ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred);template<[input_iterator](iterator.concept.input#concept:input%5Fiterator "24.3.4.9 Concept input_­iterator [iterator.concept.input]") I1, [sentinel_for](iterator.concept.sentinel#concept:sentinel%5Ffor "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<I1> S1, [input_iterator](iterator.concept.input#concept:input%5Fiterator "24.3.4.9 Concept input_­iterator [iterator.concept.input]") I2, [sentinel_for](iterator.concept.sentinel#concept:sentinel%5Ffor "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<I2> S2,class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity> requires [indirectly_comparable](alg.req.ind.cmp#concept:indirectly%5Fcomparable "24.3.7.5 Concept indirectly_­comparable [alg.req.ind.cmp]")<I1, I2, Pred, Proj1, Proj2> constexpr bool ranges::equal(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {});template<[input_range](range.refinements#concept:input%5Frange "25.4.5 Other range refinements [range.refinements]") R1, [input_range](range.refinements#concept:input%5Frange "25.4.5 Other range refinements [range.refinements]") R2, class Pred = ranges::equal_to,class Proj1 = identity, class Proj2 = identity> requires [indirectly_comparable](alg.req.ind.cmp#concept:indirectly%5Fcomparable "24.3.7.5 Concept indirectly_­comparable [alg.req.ind.cmp]")<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2> constexpr bool ranges::equal(R1&& r1, R2&& r2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {});

Let:

Returns: If last1 - first1 != last2 - first2, return false.

Otherwise return trueif E holds for every iterator i in the range [first1, last1).

Otherwise, returns false.

Complexity: If

then no applications of the corresponding predicate and each projection; otherwise,

26.6.14 Is permutation [alg.is.permutation]

template<class ForwardIterator1, class ForwardIterator2> constexpr bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2);template<class ForwardIterator1, class ForwardIterator2,class BinaryPredicate> constexpr bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, BinaryPredicate pred);template<class ForwardIterator1, class ForwardIterator2> constexpr bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2);template<class ForwardIterator1, class ForwardIterator2,class BinaryPredicate> constexpr bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred);

Let last2 be first2 + (last1 - first1)for the overloads with no parameter named last2, and let pred be equal_to{}for the overloads with no parameter pred.

Mandates: ForwardIterator1 and ForwardIterator2 have the same value type.

Preconditions: The comparison function is an equivalence relation.

Returns: If last1 - first1 != last2 - first2, return false.

Otherwise return trueif there exists a permutation of the elements in the range [first2, last2), beginning with ForwardIterator2 begin, such that equal(first1, last1, begin, pred) returns true; otherwise, returns false.

Complexity: No applications of the corresponding predicate if ForwardIterator1 and ForwardIterator2meet the requirements of random access iterators andlast1 - first1 != last2 - first2.

Otherwise, exactly last1 - first1 applications of the corresponding predicate if equal(first1, last1, first2, last2, pred) would return true; otherwise, at worst , where N has the value last1 - first1.

template<[forward_iterator](iterator.concept.forward#concept:forward%5Fiterator "24.3.4.11 Concept forward_­iterator [iterator.concept.forward]") I1, [sentinel_for](iterator.concept.sentinel#concept:sentinel%5Ffor "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<I1> S1, [forward_iterator](iterator.concept.forward#concept:forward%5Fiterator "24.3.4.11 Concept forward_­iterator [iterator.concept.forward]") I2,[sentinel_for](iterator.concept.sentinel#concept:sentinel%5Ffor "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<I2> S2, class Proj1 = identity, class Proj2 = identity,[indirect_equivalence_relation](indirectcallable.indirectinvocable#concept:indirect%5Fequivalence%5Frelation "24.3.6.3 Indirect callables [indirectcallable.indirectinvocable]")<projected<I1, Proj1>, projected<I2, Proj2>> Pred = ranges::equal_to> constexpr bool ranges::is_permutation(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {});template<[forward_range](range.refinements#concept:forward%5Frange "25.4.5 Other range refinements [range.refinements]") R1, [forward_range](range.refinements#concept:forward%5Frange "25.4.5 Other range refinements [range.refinements]") R2,class Proj1 = identity, class Proj2 = identity,[indirect_equivalence_relation](indirectcallable.indirectinvocable#concept:indirect%5Fequivalence%5Frelation "24.3.6.3 Indirect callables [indirectcallable.indirectinvocable]")<projected<iterator_t<R1>, Proj1>, projected<iterator_t<R2>, Proj2>> Pred = ranges::equal_to> constexpr bool ranges::is_permutation(R1&& r1, R2&& r2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {});

Returns: If last1 - first1 != last2 - first2, return false.

Otherwise return true if there exists a permutation of the elements in the range [first2, last2), bounded by [pfirst, plast), such thatranges​::​equal(first1, last1, pfirst, plast, pred, proj1, proj2)returns true; otherwise, returns false.

Complexity: No applications of the corresponding predicate and projections if

Otherwise, exactly last1 - first1 applications of the corresponding predicate and projections if ranges​::​equal(​first1, last1, first2, last2, pred, proj1, proj2)would return true; otherwise, at worst , where N has the value last1 - first1.

26.6.15 Search [alg.search]

template<class ForwardIterator1, class ForwardIterator2> constexpr ForwardIterator1 search(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2);template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2> ForwardIterator1 search(ExecutionPolicy&& exec, ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2);template<class ForwardIterator1, class ForwardIterator2,class BinaryPredicate> constexpr ForwardIterator1 search(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred);template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,class BinaryPredicate> ForwardIterator1 search(ExecutionPolicy&& exec, ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred);

Returns: The first iterator i in the range [first1, last1 - (last2 - first2)] such that for every non-negative integer n less than last2 - first2the following corresponding conditions hold:*(i + n) == *(first2 + n), pred(*(i + n), *(first2 + n)) != false.

Returns first1 if [first2, last2) is empty, otherwise returns last1 if no such iterator is found.

Complexity: At most (last1 - first1) * (last2 - first2) applications of the corresponding predicate.

template<[forward_iterator](iterator.concept.forward#concept:forward%5Fiterator "24.3.4.11 Concept forward_­iterator [iterator.concept.forward]") I1, [sentinel_for](iterator.concept.sentinel#concept:sentinel%5Ffor "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<I1> S1, [forward_iterator](iterator.concept.forward#concept:forward%5Fiterator "24.3.4.11 Concept forward_­iterator [iterator.concept.forward]") I2,[sentinel_for](iterator.concept.sentinel#concept:sentinel%5Ffor "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<I2> S2, class Pred = ranges::equal_to,class Proj1 = identity, class Proj2 = identity> requires [indirectly_comparable](alg.req.ind.cmp#concept:indirectly%5Fcomparable "24.3.7.5 Concept indirectly_­comparable [alg.req.ind.cmp]")<I1, I2, Pred, Proj1, Proj2> constexpr subrange<I1> ranges::search(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {});template<[forward_range](range.refinements#concept:forward%5Frange "25.4.5 Other range refinements [range.refinements]") R1, [forward_range](range.refinements#concept:forward%5Frange "25.4.5 Other range refinements [range.refinements]") R2, class Pred = ranges::equal_to,class Proj1 = identity, class Proj2 = identity> requires [indirectly_comparable](alg.req.ind.cmp#concept:indirectly%5Fcomparable "24.3.7.5 Concept indirectly_­comparable [alg.req.ind.cmp]")<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2> constexpr borrowed_subrange_t<R1> ranges::search(R1&& r1, R2&& r2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {});

Returns:

Complexity: At most (last1 - first1) * (last2 - first2) applications of the corresponding predicate and projections.

template<class ForwardIterator, class Size, class T = iterator_traits<ForwardIterator>::value_type> constexpr ForwardIterator search_n(ForwardIterator first, ForwardIterator last, Size count, const T& value);template<class ExecutionPolicy, class ForwardIterator, class Size,class T = iterator_traits<ForwardIterator>::value_type> ForwardIterator search_n(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last, Size count, const T& value);template<class ForwardIterator, class Size, class T = iterator_traits<ForwardIterator>::value_type,class BinaryPredicate> constexpr ForwardIterator search_n(ForwardIterator first, ForwardIterator last, Size count, const T& value, BinaryPredicate pred);template<class ExecutionPolicy, class ForwardIterator, class Size,class T = iterator_traits<ForwardIterator>::value_type,class BinaryPredicate> ForwardIterator search_n(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last, Size count, const T& value, BinaryPredicate pred);

Let E be pred(*(i + n), value) != falsefor the overloads with a parameter pred, and *(i + n) == value otherwise.

Returns: The first iterator i in the range [first, last - count] such that for every non-negative integer n less than countthe condition E is true.

Returns last if no such iterator is found.

Complexity: At most last - first applications of the corresponding predicate.

template<[forward_iterator](iterator.concept.forward#concept:forward%5Fiterator "24.3.4.11 Concept forward_­iterator [iterator.concept.forward]") I, [sentinel_for](iterator.concept.sentinel#concept:sentinel%5Ffor "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<I> S,class Pred = ranges::equal_to, class Proj = identity,class T = projected_value_t<I, Proj>> requires [indirectly_comparable](alg.req.ind.cmp#concept:indirectly%5Fcomparable "24.3.7.5 Concept indirectly_­comparable [alg.req.ind.cmp]")<I, const T*, Pred, Proj> constexpr subrange<I> ranges::search_n(I first, S last, iter_difference_t<I> count,const T& value, Pred pred = {}, Proj proj = {});template<[forward_range](range.refinements#concept:forward%5Frange "25.4.5 Other range refinements [range.refinements]") R, class Pred = ranges::equal_to,class Proj = identity, class T = projected_value_t<iterator_t<R>, Proj>> requires [indirectly_comparable](alg.req.ind.cmp#concept:indirectly%5Fcomparable "24.3.7.5 Concept indirectly_­comparable [alg.req.ind.cmp]")<iterator_t<R>, const T*, Pred, Proj> constexpr borrowed_subrange_t<R> ranges::search_n(R&& r, range_difference_t<R> count,const T& value, Pred pred = {}, Proj proj = {});

Returns: {i, i + count}where i is the first iterator in the range [first, last - count] such that for every non-negative integer n less than count, the following condition holds:invoke(pred, invoke(proj, *(i + n)), value).

Returns {last, last} if no such iterator is found.

Complexity: At most last - first applications of the corresponding predicate and projection.

template<class ForwardIterator, class Searcher> constexpr ForwardIterator search(ForwardIterator first, ForwardIterator last, const Searcher& searcher);

Effects: Equivalent to: return searcher(first, last).first;

26.6.16 Starts with [alg.starts.with]

template<[input_iterator](iterator.concept.input#concept:input%5Fiterator "24.3.4.9 Concept input_­iterator [iterator.concept.input]") I1, [sentinel_for](iterator.concept.sentinel#concept:sentinel%5Ffor "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<I1> S1, [input_iterator](iterator.concept.input#concept:input%5Fiterator "24.3.4.9 Concept input_­iterator [iterator.concept.input]") I2, [sentinel_for](iterator.concept.sentinel#concept:sentinel%5Ffor "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<I2> S2,class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity> requires [indirectly_comparable](alg.req.ind.cmp#concept:indirectly%5Fcomparable "24.3.7.5 Concept indirectly_­comparable [alg.req.ind.cmp]")<I1, I2, Pred, Proj1, Proj2> constexpr bool ranges::starts_with(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {});template<[input_range](range.refinements#concept:input%5Frange "25.4.5 Other range refinements [range.refinements]") R1, [input_range](range.refinements#concept:input%5Frange "25.4.5 Other range refinements [range.refinements]") R2, class Pred = ranges::equal_to, class Proj1 = identity,class Proj2 = identity> requires [indirectly_comparable](alg.req.ind.cmp#concept:indirectly%5Fcomparable "24.3.7.5 Concept indirectly_­comparable [alg.req.ind.cmp]")<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2> constexpr bool ranges::starts_with(R1&& r1, R2&& r2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {});

Returns: ranges::mismatch(std::move(first1), last1, std::move(first2), last2, pred, proj1, proj2).in2 == last2

26.6.17 Ends with [alg.ends.with]

template<[input_iterator](iterator.concept.input#concept:input%5Fiterator "24.3.4.9 Concept input_­iterator [iterator.concept.input]") I1, [sentinel_for](iterator.concept.sentinel#concept:sentinel%5Ffor "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<I1> S1, [input_iterator](iterator.concept.input#concept:input%5Fiterator "24.3.4.9 Concept input_­iterator [iterator.concept.input]") I2, [sentinel_for](iterator.concept.sentinel#concept:sentinel%5Ffor "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<I2> S2,class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity> requires ([forward_iterator](iterator.concept.forward#concept:forward%5Fiterator "24.3.4.11 Concept forward_­iterator [iterator.concept.forward]")<I1> || [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized%5Fsentinel%5Ffor "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<S1, I1>) && ([forward_iterator](iterator.concept.forward#concept:forward%5Fiterator "24.3.4.11 Concept forward_­iterator [iterator.concept.forward]")<I2> || [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized%5Fsentinel%5Ffor "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<S2, I2>) && [indirectly_comparable](alg.req.ind.cmp#concept:indirectly%5Fcomparable "24.3.7.5 Concept indirectly_­comparable [alg.req.ind.cmp]")<I1, I2, Pred, Proj1, Proj2> constexpr bool ranges::ends_with(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {});

Let N1 be last1 - first1 andN2 be last2 - first2.

Returns: false if N1 < N2, otherwiseranges::equal(std::move(first1) + (N1 - N2), last1, std::move(first2), last2, pred, proj1, proj2)

template<[input_range](range.refinements#concept:input%5Frange "25.4.5 Other range refinements [range.refinements]") R1, [input_range](range.refinements#concept:input%5Frange "25.4.5 Other range refinements [range.refinements]") R2, class Pred = ranges::equal_to, class Proj1 = identity,class Proj2 = identity> requires ([forward_range](range.refinements#concept:forward%5Frange "25.4.5 Other range refinements [range.refinements]")<R1> || [sized_range](range.sized#concept:sized%5Frange "25.4.3 Sized ranges [range.sized]")<R1>) && ([forward_range](range.refinements#concept:forward%5Frange "25.4.5 Other range refinements [range.refinements]")<R2> || [sized_range](range.sized#concept:sized%5Frange "25.4.3 Sized ranges [range.sized]")<R2>) && [indirectly_comparable](alg.req.ind.cmp#concept:indirectly%5Fcomparable "24.3.7.5 Concept indirectly_­comparable [alg.req.ind.cmp]")<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2> constexpr bool ranges::ends_with(R1&& r1, R2&& r2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {});

Let N1 be ranges​::​distance(r1) andN2 be ranges​::​distance(r2).

Returns: false if N1 < N2, otherwiseranges::equal(views::drop(ranges::ref_view(r1), N1 - static_cast<decltype(N1)>(N2)), r2, pred, proj1, proj2)

26.6.18 Fold [alg.fold]

template<[input_iterator](iterator.concept.input#concept:input%5Fiterator "24.3.4.9 Concept input_­iterator [iterator.concept.input]") I, [sentinel_for](iterator.concept.sentinel#concept:sentinel%5Ffor "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<I> S, class T = iter_value_t<I>,[_indirectly-binary-left-foldable_](algorithm.syn#concept:indirectly-binary-left-foldable "26.4 Header <algorithm> synopsis [algorithm.syn]")<T, I> F> constexpr auto ranges::fold_left(I first, S last, T init, F f);template<[input_range](range.refinements#concept:input%5Frange "25.4.5 Other range refinements [range.refinements]") R, class T = range_value_t<R>,[_indirectly-binary-left-foldable_](algorithm.syn#concept:indirectly-binary-left-foldable "26.4 Header <algorithm> synopsis [algorithm.syn]")<T, iterator_t<R>> F> constexpr auto ranges::fold_left(R&& r, T init, F f);

Returns: ranges::fold_left_with_iter(std::move(first), last, std::move(init), f).value

template<[input_iterator](iterator.concept.input#concept:input%5Fiterator "24.3.4.9 Concept input_­iterator [iterator.concept.input]") I, [sentinel_for](iterator.concept.sentinel#concept:sentinel%5Ffor "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<I> S,[_indirectly-binary-left-foldable_](algorithm.syn#concept:indirectly-binary-left-foldable "26.4 Header <algorithm> synopsis [algorithm.syn]")<iter_value_t<I>, I> F> requires [constructible_from](concept.constructible#concept:constructible%5Ffrom "18.4.11 Concept constructible_­from [concept.constructible]")<iter_value_t<I>, iter_reference_t<I>> constexpr auto ranges::fold_left_first(I first, S last, F f);template<[input_range](range.refinements#concept:input%5Frange "25.4.5 Other range refinements [range.refinements]") R, [_indirectly-binary-left-foldable_](algorithm.syn#concept:indirectly-binary-left-foldable "26.4 Header <algorithm> synopsis [algorithm.syn]")<range_value_t<R>, iterator_t<R>> F> requires [constructible_from](concept.constructible#concept:constructible%5Ffrom "18.4.11 Concept constructible_­from [concept.constructible]")<range_value_t<R>, range_reference_t<R>> constexpr auto ranges::fold_left_first(R&& r, F f);

Returns: ranges::fold_left_first_with_iter(std::move(first), last, f).value

template<[bidirectional_iterator](iterator.concept.bidir#concept:bidirectional%5Fiterator "24.3.4.12 Concept bidirectional_­iterator [iterator.concept.bidir]") I, [sentinel_for](iterator.concept.sentinel#concept:sentinel%5Ffor "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<I> S, class T = iter_value_t<I>,[_indirectly-binary-right-foldable_](algorithm.syn#concept:indirectly-binary-right-foldable "26.4 Header <algorithm> synopsis [algorithm.syn]")<T, I> F> constexpr auto ranges::fold_right(I first, S last, T init, F f);template<[bidirectional_range](range.refinements#concept:bidirectional%5Frange "25.4.5 Other range refinements [range.refinements]") R, class T = range_value_t<R>,[_indirectly-binary-right-foldable_](algorithm.syn#concept:indirectly-binary-right-foldable "26.4 Header <algorithm> synopsis [algorithm.syn]")<T, iterator_t<R>> F> constexpr auto ranges::fold_right(R&& r, T init, F f);

Effects: Equivalent to:using U = decay_t<invoke_result_t<F&, iter_reference_t<I>, T>>;if (first == last) return U(std::move(init)); I tail = ranges::next(first, last); U accum = invoke(f, *--tail, std::move(init));while (first != tail) accum = invoke(f, *--tail, std::move(accum));return accum;

template<[bidirectional_iterator](iterator.concept.bidir#concept:bidirectional%5Fiterator "24.3.4.12 Concept bidirectional_­iterator [iterator.concept.bidir]") I, [sentinel_for](iterator.concept.sentinel#concept:sentinel%5Ffor "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<I> S,[_indirectly-binary-right-foldable_](algorithm.syn#concept:indirectly-binary-right-foldable "26.4 Header <algorithm> synopsis [algorithm.syn]")<iter_value_t<I>, I> F> requires [constructible_from](concept.constructible#concept:constructible%5Ffrom "18.4.11 Concept constructible_­from [concept.constructible]")<iter_value_t<I>, iter_reference_t<I>> constexpr auto ranges::fold_right_last(I first, S last, F f);template<[bidirectional_range](range.refinements#concept:bidirectional%5Frange "25.4.5 Other range refinements [range.refinements]") R,[_indirectly-binary-right-foldable_](algorithm.syn#concept:indirectly-binary-right-foldable "26.4 Header <algorithm> synopsis [algorithm.syn]")<range_value_t<R>, iterator_t<R>> F> requires [constructible_from](concept.constructible#concept:constructible%5Ffrom "18.4.11 Concept constructible_­from [concept.constructible]")<range_value_t<R>, range_reference_t<R>> constexpr auto ranges::fold_right_last(R&& r, F f);

Let U bedecltype(ranges​::​fold_right(first, last, iter_value_t<I>(*first), f)).

Effects: Equivalent to:if (first == last) return optional<U>(); I tail = ranges::prev(ranges::next(first, std::move(last)));return optional<U>(in_place, ranges::fold_right(std::move(first), tail, iter_value_t<I>(*tail), std::move(f)));

template<[input_iterator](iterator.concept.input#concept:input%5Fiterator "24.3.4.9 Concept input_­iterator [iterator.concept.input]") I, [sentinel_for](iterator.concept.sentinel#concept:sentinel%5Ffor "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<I> S, class T = iter_value_t<I>,[_indirectly-binary-left-foldable_](algorithm.syn#concept:indirectly-binary-left-foldable "26.4 Header <algorithm> synopsis [algorithm.syn]")<T, I> F> constexpr _see below_ ranges::fold_left_with_iter(I first, S last, T init, F f);template<[input_range](range.refinements#concept:input%5Frange "25.4.5 Other range refinements [range.refinements]") R, class T = range_value_t<R>,[_indirectly-binary-left-foldable_](algorithm.syn#concept:indirectly-binary-left-foldable "26.4 Header <algorithm> synopsis [algorithm.syn]")<T, iterator_t<R>> F> constexpr _see below_ ranges::fold_left_with_iter(R&& r, T init, F f);

Let U be decay_t<invoke_result_t<F&, T, iter_reference_t<I>>>.

Effects: Equivalent to:if (first == last) return {std::move(first), U(std::move(init))}; U accum = invoke(f, std::move(init), *first);for (++first; first != last; ++first) accum = invoke(f, std::move(accum), *first);return {std::move(first), std::move(accum)};

Remarks: The return type isfold_left_with_iter_result<I, U> for the first overload andfold_left_with_iter_result<borrowed_iterator_t<R>, U>for the second overload.

template<[input_iterator](iterator.concept.input#concept:input%5Fiterator "24.3.4.9 Concept input_­iterator [iterator.concept.input]") I, [sentinel_for](iterator.concept.sentinel#concept:sentinel%5Ffor "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<I> S,[_indirectly-binary-left-foldable_](algorithm.syn#concept:indirectly-binary-left-foldable "26.4 Header <algorithm> synopsis [algorithm.syn]")<iter_value_t<I>, I> F> requires [constructible_from](concept.constructible#concept:constructible%5Ffrom "18.4.11 Concept constructible_­from [concept.constructible]")<iter_value_t<I>, iter_reference_t<I>> constexpr _see below_ ranges::fold_left_first_with_iter(I first, S last, F f);template<[input_range](range.refinements#concept:input%5Frange "25.4.5 Other range refinements [range.refinements]") R, [_indirectly-binary-left-foldable_](algorithm.syn#concept:indirectly-binary-left-foldable "26.4 Header <algorithm> synopsis [algorithm.syn]")<range_value_t<R>, iterator_t<R>> F> requires [constructible_from](concept.constructible#concept:constructible%5Ffrom "18.4.11 Concept constructible_­from [concept.constructible]")<range_value_t<R>, range_reference_t<R>> constexpr _see below_ ranges::fold_left_first_with_iter(R&& r, F f);

Let U bedecltype(ranges::fold_left(std::move(first), last, iter_value_t<I>(*first), f))

Effects: Equivalent to:if (first == last) return {std::move(first), optional<U>()}; optional<U> init(in_place, *first);for (++first; first != last; ++first) *init = invoke(f, std::move(*init), *first);return {std::move(first), std::move(init)};

Remarks: The return type isfold_left_first_with_iter_result<I, optional<U>>for the first overload andfold_left_first_with_iter_result<borrowed_iterator_t<R>, optional<U>>for the second overload.