Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

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

NAME
       std::experimental::ranges::search_n	    -	       std::experimen-
       tal::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
       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 projec-
       tion.

Possible implementation
	  template<ForwardIterator I, Sentinel<I> S, class T,
		   class Pred =	ranges::equal_to<>, class Proj = ranges::iden-
       tity>
	      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)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::experimental::ranges::search_n&sektion=3&manpath=FreeBSD+Ports+15.1.quarterly>

home | help