SysTutorials

Linux Manual Pages › Section 3

stdexperimentalrangessearch_n(3)

std::experimental::ranges::search_n – std::experimental::ranges::search_n

Synopsis

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>(1)
(ranges TS)
    I search_n(I first, S last, ranges::difference_type_t<I> count,
               const T &value, Pred pred = Pred{}, Proj proj = Proj{});
template <ForwardRange R, class T, class Pred = ranges::equal_to<>,
          class Proj = ranges::identity>
requires IndirectlyComparable < ranges::iterator_t<R>,
const T *, Pred, Proj > (2)(ranges TS)
                            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{});

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

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