Namespaces
Variants
Views
Actions

std::experimental::ranges::search_n

From cppreference.com
< cpp‎ | experimental‎ | ranges
 
 
Experimental
Technical Specification
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)
Experimental Non-TS
Pattern Matching
Linear Algebra
std::execution
Contracts
2D Graphics
 
 
 
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 [firstlast) 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.

Contents

[edit] 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

[edit] Return value

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

[edit] Complexity

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

[edit] 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;
}

[edit] Example

[edit] See also

searches a range for a number of consecutive copies of an element
(function template) [edit]
finds the last sequence of elements in a certain range
(function template) [edit]
finds the first element satisfying specific criteria
(function template) [edit]
searches for a range of elements
(function template) [edit]