# std::experimental::ranges::search_n

From cppreference.com
< cpp‎ | experimental‎ | ranges

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;
    }

### Example

| This section is incomplete Reason: no example

### 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)
find find_if find_if_not | finds the first element satisfying specific criteria (function template)
search | searches for a range of elements (function template)

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/experimental/ranges/algorithm/search_n&oldid=155288"