std::find,std::find_if,std::find_if_not (3) - Linux Man Pages

std::find,std::find_if,std::find_if_not: std::find,std::find_if,std::find_if_not

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 > (until C++20)
InputIt find( InputIt first, InputIt last, const T& value );
template< class InputIt, class T > (since C++20)
constexpr InputIt find( InputIt first, InputIt last, const T& value );
template< class ExecutionPolicy, class ForwardIt, class T > (2) (since C++17)
ForwardIt find( ExecutionPolicy&& policy, ForwardIt first, ForwardIt last, const T& value );
template< class InputIt, class UnaryPredicate >
InputIt find_if( InputIt first, InputIt last, (until C++20)
UnaryPredicate p );
template< class InputIt, class UnaryPredicate >
constexpr InputIt find_if( InputIt first, InputIt last, (since C++20)
UnaryPredicate p ); (1)
template< class ExecutionPolicy, class ForwardIt, class UnaryPredicate >
ForwardIt find_if( ExecutionPolicy&& policy, ForwardIt first, ForwardIt last, (4) (since C++17)
UnaryPredicate p ); (3)
template< class InputIt, class UnaryPredicate > (since C++11)
InputIt find_if_not( InputIt first, InputIt last, (until C++20)
UnaryPredicate q );
template< class InputIt, class UnaryPredicate >
constexpr InputIt find_if_not( InputIt first, InputIt last, (5) (since C++20)
UnaryPredicate q );
template< class ExecutionPolicy, class ForwardIt, class UnaryPredicate >
ForwardIt find_if_not( ExecutionPolicy&& policy, ForwardIt first, ForwardIt last, (6) (since C++17)
UnaryPredicate q );


Returns 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. This overload only participates in overload resolution if std::is_execution_policy_v<std::decay_t<ExecutionPolicy>> 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.
p - The expression p(v) must be convertible to bool for every argument v 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.
q - The expression q(v) must be convertible to bool for every argument v 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 last - first applications of the predicate

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::terminate 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, UnaryPredicate 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 an integer in a vector of integers.
// Run this code


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


  int main()
  {
      int n1 = 3;
      int n2 = 5;


      std::vector<int> v{0, 1, 2, 3, 4};


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


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


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

Output:


  v contains: 3
  v does not contain: 5

See also


              finds the first two adjacent items that are equal (or satisfy a given predicate)
adjacent_find (function template)
              finds the last sequence of elements in a certain range
find_end (function template)
              searches for any one of a set of elements
find_first_of (function template)
              finds the first position where two ranges differ
mismatch (function template)
              searches for a range of elements
search (function template)