std::find_first_of (3) - Linux Manuals

std::find_first_of: std::find_first_of

NAME

std::find_first_of - std::find_first_of

Synopsis

Defined in header <algorithm>
template< class ForwardIt1, class ForwardIt2 >
ForwardIt1 find_first_of( ForwardIt1 first, ForwardIt1 last, (until C++11)
ForwardIt2 s_first, ForwardIt2 s_last );
template< class InputIt, class ForwardIt > (since C++11)
InputIt find_first_of( InputIt first, InputIt last, (until C++20)
ForwardIt s_first, ForwardIt s_last );
template< class InputIt, class ForwardIt >
constexpr InputIt find_first_of( InputIt first, InputIt last, (since C++20)
ForwardIt s_first, ForwardIt s_last );
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2 >
ForwardIt1 find_first_of( ExecutionPolicy&& policy, ForwardIt1 first, ForwardIt1 last, (2) (since C++17)
ForwardIt2 s_first, ForwardIt2 s_last ); (1)
template< class ForwardIt1, class ForwardIt2, class BinaryPredicate >
ForwardIt1 find_first_of( ForwardIt1 first, ForwardIt1 last, (until C++11)
ForwardIt2 s_first, ForwardIt2 s_last, BinaryPredicate p );
template< class InputIt, class ForwardIt, class BinaryPredicate > (since C++11)
InputIt find_first_of( InputIt first, InputIt last, (until C++20)
ForwardIt s_first, ForwardIt s_last, BinaryPredicate p ); (3)
template< class InputIt, class ForwardIt, class BinaryPredicate >
constexpr InputIt find_first_of( InputIt first, InputIt last, (since C++20)
ForwardIt s_first, ForwardIt s_last, BinaryPredicate p );
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2, class BinaryPredicate >
ForwardIt1 find_first_of( ExecutionPolicy&& policy, ForwardIt1 first, ForwardIt last, (4) (since C++17)
ForwardIt2 s_first, ForwardIt2 s_last, BinaryPredicate p );

Searches the range [first, last) for any of the elements in the range [s_first, s_last).
1) Elements are compared using operator==.
3) Elements are compared using the given binary predicate p.
2,4) Same as (1,3), 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
s_first, s_last - the range of elements to search for
policy - the execution policy to use. See execution_policy for details.
                  binary predicate which returns true if the elements should be treated as equal.
                  The signature of the predicate function should be equivalent to the following:
                  bool pred(const Type1 &a, const Type2 &b);
p - While the signature does not need to have const &, the function must not modify the objects passed to it and must be able to accept all values of type (possibly const) Type1 and Type2 regardless of value_category (thus, Type1 & is not allowed
                  , nor is Type1 unless for Type1 a move is equivalent to a copy
                  (since C++11)).
                  The types Type1 and Type2 must be such that objects of types ForwardIt1 and ForwardIt2 can be dereferenced and then implicitly converted to Type1 and Type2 respectively.

Type requirements

-
InputIt must meet the requirements of LegacyInputIterator.
-
ForwardIt1 must meet the requirements of LegacyForwardIterator.
-
ForwardIt2 must meet the requirements of LegacyForwardIterator.

Return value

Iterator to the first element in the range [first, last) that is equal to an element from the range [s_first; s_last). If no such element is found, last is returned.

Complexity

Does at most (S*N) comparisons where S = distance(s_first, s_last) and N = distance(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::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 ForwardIt>
  InputIt find_first_of(InputIt first, InputIt last,
                        ForwardIt s_first, ForwardIt s_last)
  {
      for (; first != last; ++first) {
          for (ForwardIt it = s_first; it != s_last; ++it) {
              if (*first == *it) {
                  return first;
              }
          }
      }
      return last;
  }

Second version

  template<class InputIt, class ForwardIt, class BinaryPredicate>
  InputIt find_first_of(InputIt first, InputIt last,
                        ForwardIt s_first, ForwardIt s_last,
                        BinaryPredicate p)
  {
      for (; first != last; ++first) {
          for (ForwardIt it = s_first; it != s_last; ++it) {
              if (p(*first, *it)) {
                  return first;
              }
          }
      }
      return last;
  }

Example

The following code searches for any of specified integers in a vector of integers:
// Run this code

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

  int main()
  {
      std::vector<int> v{0, 2, 3, 25, 5};
      std::vector<int> t{3, 19, 10, 2};

      auto result = std::find_first_of(v.begin(), v.end(), t.begin(), t.end());

      if (result == v.end()) {
          std::cout << "no elements of v were equal to 3, 19, 10 or 2\n";
      } else {
          std::cout << "found a match at "
                    << std::distance(v.begin(), result) << "\n";
      }
   }

Output:

  found a match at 1