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>
       (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  projec-
       tion.

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)

http://cppreference.com		  2022.07.31	 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.0>

home | help