Std::find_first_of (3) Linux Manual Page

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

std::find_first_of (3) Linux Manual Page