home | help 
std::experi...es::search_n(3)  C++ Standard Libary std::experi...es::search_n(3)

NAME
     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>
	ranges::safe_iterator_t<R> search_n( R&& r,			     (2)
     (ranges TS)

	 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 ele-
     ments 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::be-
     gin(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 re-
     turned.

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

Category:
	  * Todo no example

http://cppreference.com 	   2024.06.10	   std::experi...es::search_n(3)
home | help