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

FreeBSD Manual Pages

  
 
  

home | help 
std::find,s...:find_if_not(3) C++ Standard Libarystd::find,s...:find_if_not(3)

NAME
       std::find,std::find_if,std::find_if_not				     -
       std::find,std::find_if,std::find_if_not

Synopsis
	  Defined in header <algorithm>
	  template< class InputIt, class T >
	  InputIt find(	InputIt	first, InputIt		   (until C++20)
	  last,	const T& value );
	  template< class InputIt, class T >
	  constexpr InputIt find( InputIt first,	   (since C++20)
	  InputIt last,	const T& value );
	  template< class ExecutionPolicy, class
	  ForwardIt, class T >

	  ForwardIt find( ExecutionPolicy&&	       (2) (since C++17)
	  policy, ForwardIt first, ForwardIt last,

	  const	T& value );
	  template< class InputIt, class
	  UnaryPredicate >

	  InputIt find_if( InputIt first, InputIt			  (un-
       til C++20)
	  last,

	  UnaryPredicate p );
	  template< class InputIt, class
	  UnaryPredicate >

	  constexpr		InputIt		   find_if(	       InputIt
       (since C++20)
	  first, InputIt last,

	  UnaryPredicate p );
	  template< class ExecutionPolicy, class   (1)
	  ForwardIt, class UnaryPredicate >

	  ForwardIt	 find_if(      ExecutionPolicy&&		   (4)
       (since C++17)
	  policy, ForwardIt first, ForwardIt last,

	  UnaryPredicate p );			       (3)
	  template< class InputIt, class
	  UnaryPredicate						     >
       (since
										       C++11)
	  InputIt	     find_if_not(	     InputIt		first,
       (until
	  InputIt							 last,
       C++20)

	  UnaryPredicate q );
	  template< class InputIt, class
	  UnaryPredicate >
										       (since
	  constexpr	InputIt	    find_if_not(     InputIt		   (5)
       C++20)
	  first, InputIt last,

	  UnaryPredicate q );
	  template< class ExecutionPolicy, class
	  ForwardIt, class UnaryPredicate >
										       (since
	  ForwardIt  find_if_not(  ExecutionPolicy&&			   (6)
       C++17)
	  policy, ForwardIt first, ForwardIt last,

	  UnaryPredicate q );

	  Returns an iterator to the first element in the range	[first,	 last)
       that satisfies
	  specific criteria:

	  1) find searches for an element equal	to value
	  3)  find_if  searches	 for  an element for which predicate p returns
       true
	  5) find_if_not searches for an element for which predicate q returns
       false
	  2,4,6) Same as (1,3,5), but  executed	 according  to	policy.	 These
       overloads do not
	  participate in overload resolution unless
	  std::is_execution_policy_v<std::decay_t<ExecutionPolicy>>
	  (until C++20)
	  std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>
	  (since C++20)	is true.

Parameters
	  first, last -	the range of elements to examine
	  value	      -	value to compare the elements to
	  policy       - the execution policy to use. See execution policy for
       details.
			unary predicate	which returns true  for	 the  required
       element.

			The  expression	 p(v)  must be convertible to bool for
       every argument v
	  p	      -	of type	(possibly const) VT, where  VT	is  the	 value
       type of InputIt,
			regardless  of	value category,	and must not modify v.
       Thus, a parameter
			type of	VT&is not allowed
			, nor is VT unless for VT a move is  equivalent	 to  a
       copy
			(since C++11).
			unary  predicate  which	returns	false for the required
       element.

			The expression q(v) must be convertible	 to  bool  for
       every argument v
	  q	       -  of  type  (possibly const) VT, where VT is the value
       type of InputIt,
			regardless of value category, and must not  modify  v.
       Thus, a parameter
			type of	VT&is not allowed
			,  nor	is  VT unless for VT a move is equivalent to a
       copy
			(since C++11).

Type requirements
	  -
	  InputIt must meet the	requirements of	LegacyInputIterator.
	  -
	  ForwardIt must meet the requirements of LegacyForwardIterator.
	  -
	  UnaryPredicate must meet the requirements of Predicate.

Return value
	  Iterator to the first	element	satisfying the condition or last if no
       such element is
	  found.

Complexity
	  At most N  applications  of  the  predicate,	where  N  =  std::dis-
       tance(first, last).

Exceptions
	  The overloads	with a template	parameter named	ExecutionPolicy	report
       errors as
	  follows:

	    *  If  execution  of  a  function invoked as part of the algorithm
       throws an exception
	      and ExecutionPolicy is one of the	standard policies, std::termi-
       nate is called.
	      For any other ExecutionPolicy, the behavior  is  implementation-
       defined.
	    *  If  the	algorithm  fails to allocate memory, std::bad_alloc is
       thrown.

Possible implementation
First version
	  template<class InputIt, class	T>
	  constexpr InputIt find(InputIt first,	InputIt	last, const T& value)
	  {
	      for (; first != last; ++first) {
		  if (*first ==	value) {
		      return first;
		  }
	      }
	      return last;
	  }

Second version
	  template<class InputIt, class	UnaryPredicate>
	  constexpr InputIt find_if(InputIt first, InputIt  last,  UnaryPredi-
       cate p)
	  {
	      for (; first != last; ++first) {
		  if (p(*first)) {
		      return first;
		  }
	      }
	      return last;
	  }
					 Third version
	  template<class InputIt, class	UnaryPredicate>
	  constexpr   InputIt	find_if_not(InputIt   first,   InputIt	 last,
       UnaryPredicate q)
	  {
	      for (; first != last; ++first) {
		  if (!q(*first)) {
		      return first;
		  }
	      }
	      return last;
	  }

Notes
	  If you do not	have C++11, an equivalent to  std::find_if_not	is  to
       use std::find_if
	  with the negated predicate.

	  template<class InputIt, class	UnaryPredicate>
	  InputIt find_if_not(InputIt first, InputIt last, UnaryPredicate q)
	  {
	      return std::find_if(first, last, std::not1(q));
	  }

Example
	  The following	example	finds integers in given	vector.

       // Run this code

	#include <iostream>
	#include <algorithm>
	#include <vector>
	#include <iterator>

	int main()
	{
	    std::vector<int> v{1, 2, 3,	4};
	    int	n1 = 3;
	    int	n2 = 5;
	    auto is_even = [](int i){ return i%2 == 0; };

	    auto result1 = std::find(begin(v), end(v), n1);
	    auto result2 = std::find(begin(v), end(v), n2);
	    auto result3 = std::find_if(begin(v), end(v), is_even);

	    (result1 !=	std::end(v))
		? std::cout << "v contains " <<	n1 << '\n'
		: std::cout << "v does not contain " <<	n1 << '\n';

	    (result2 !=	std::end(v))
		? std::cout << "v contains " <<	n2 << '\n'
		: std::cout << "v does not contain " <<	n2 << '\n';

	    (result3 !=	std::end(v))
		?  std::cout  <<  "v contains an even number: "	<< *result3 <<
       '\n'
		: std::cout << "v does not contain even	numbers\n";
	}

Output:
	v contains 3
	v does not contain 5
	v contains an even number: 2

See also
			      finds the	first  two  adjacent  items  that  are
       equal (or satisfy a
	  adjacent_find	      given predicate)
			      (function	template)
	  find_end	      finds the	last sequence of elements in a certain
       range
			      (function	template)
	  find_first_of	      searches for any one of a	set of elements
			      (function	template)
	  mismatch	      finds the	first position where two ranges	differ
			      (function	template)
	  search	      searches for a range of elements
			      (function	template)
	  ranges::find
	  ranges::find_if
	  ranges::find_if_not finds the	first element satisfying specific cri-
       teria
	  (C++20)	      (niebloid)
	  (C++20)
	  (C++20)

http://cppreference.com		  2022.07.31	 std::find,s...:find_if_not(3)

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

home | help