std::experimental::ranges::search_n

 

C++

Compiler support

Freestanding and hosted

Language

Standard library headers

Named requirements

Feature test macros (C++20)

Language support library

Concepts library (C++20)

Metaprogramming library (C++11)

Diagnostics library

General utilities library

Strings library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Numerics library

Localizations library

Input/output library

Filesystem library (C++17)

Regular expressions library (C++11)

Concurrency support library (C++11)

Technical specifications

Symbols index

External libraries

 

Technical specifications

Filesystem library (filesystem TS)

Library fundamentals (library fundamentals TS)

Library fundamentals 2 (library fundamentals TS v2)

Library fundamentals 3 (library fundamentals TS v3)

Extensions for parallelism (parallelism TS)

Extensions for parallelism 2 (parallelism TS v2)

Extensions for concurrency (concurrency TS)

Extensions for concurrency 2 (concurrency TS v2)

Concepts (concepts TS)

Ranges (ranges TS)

Reflection (reflection TS)

Mathematical special functions (special functions TR)

 

Ranges

Concepts

General utilities

Iterators

Ranges

Algorithms

 

Algorithms library

Non-modifying sequence operations
all_ofany_ofnone_of countcount_if	findfind_iffind_if_not find_end find_first_of	adjacent_find search search_n mismatch	equal for_each lexicographical_compare
Modifying sequence operations
copycopy_if copy_n copy_backward move move_backward	fill fill_n generate generate_n swap_ranges shuffle transform	removeremove_if replacereplace_if reverse rotate unique	remove_copyremove_copy_if replace_copyreplace_copy_if reverse_copy rotate_copy unique_copy
Partitioning operations
is_partitioned partition_point	partition partition_copy	stable_partition
Sorting operations
is_sorted is_sorted_until	sort stable_sort	partial_sort partial_sort_copy	nth_element
Binary search operations
lower_bound	upper_bound	binary_search	equal_range
Set operations (on sorted ranges)
merge inplace_merge	includes	set_difference set_intersection	set_symmetric_difference set_union
Heap operations
is_heap is_heap_until	make_heap sort_heap	push_heap pop_heap
Minimum/maximum operations
max max_element	min min_element	minmax minmax_element
Permutations
is_permutation	next_permutation	prev_permutation

 

Defined in header <experimental/ranges/algorithm>
template< ForwardIterator I, Sentinel<I> S, class T,           class Pred = ranges::equal_to<>, class Proj = ranges::identity >   requires IndirectlyComparable<I, const T*, Pred, Proj> I search_n(I first, S last, ranges::difference_type_t<I> count,            const T& value, Pred pred = Pred{}, Proj proj = Proj{});	(1)	(ranges TS)
template< ForwardRange R, class T, class Pred = ranges::equal_to<>,           class Proj = ranges::identity >   requires IndirectlyComparable<ranges::iterator_t<R>, const T*, Pred, Proj> ranges::safe_iterator_t<R> search_n(R&& r,                                     ranges::difference_type_t<ranges::iterator_t<R>> count,                                     const T& value, Pred pred = Pred{}, Proj proj = Proj{});	(2)	(ranges TS)

1) Searches the range [first, last) for the first sequence of count elements whose projected values are each equal to the given value value according to the predicate pred.

2) Same as (1), but uses r as the source range, as if using ranges::begin(r) as first and ranges::end(r) as last.

Parameters

first, last	-	the range of elements to examine
r	-	the range of elements to examine
count	-	the length of the sequence to search for
value	-	the value to search for
pred	-	the predicate that compares the projected elements with value
proj	-	the projection to apply to the elements

Return value

Iterator to the beginning of the found sequence in the range [first, last). If no such sequence is found, an iterator that compares equal to last is returned.

Complexity

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

Possible implementation

template< ForwardIterator I, Sentinel<I> S, class T, class Pred = ranges::equal_to<>, class Proj = ranges::identity > requires IndirectlyComparable<I, const T*, Pred, Proj> I search_n(I first, S last, ranges::difference_type_t<I> count, const T& value, Pred pred = Pred{}, Proj proj = Proj{}) { for(; first != last; ++first) { if (!ranges::invoke(pred, ranges::invoke(proj, *first), value)) { continue; }   I candidate = first; ranges::difference_type_t<I> cur_count = 0;   while (true) { ++cur_count; if (cur_count == count) { // success return candidate; } ++first; if (first == last) { // exhausted the list return first; } if (!ranges::invoke(pred, ranges::invoke(proj, *first), value)) { // too few in a row break; } } } return first; }

See also

search_n	searches a range for a number of consecutive copies of an element (function template)
find_end	finds the last sequence of elements in a certain range (function template)
findfind_iffind_if_not	finds the first element satisfying specific criteria (function template)
search	searches for a range of elements (function template)