Defined in header `<algorithm>` | ||
---|---|---|

(1) | ||

template< class ForwardIt1, class ForwardIt2 > ForwardIt1 find_first_of( ForwardIt1 first, ForwardIt1 last, ForwardIt2 s_first, ForwardIt2 s_last ); | (until C++11) | |

template< class InputIt, class ForwardIt > InputIt find_first_of( InputIt first, InputIt last, ForwardIt s_first, ForwardIt s_last ); | (since C++11) (until C++20) | |

template< class InputIt, class ForwardIt > constexpr InputIt find_first_of( InputIt first, InputIt last, ForwardIt s_first, ForwardIt s_last ); | (since C++20) | |

template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2 > ForwardIt1 find_first_of( ExecutionPolicy&& policy, ForwardIt1 first, ForwardIt1 last, ForwardIt2 s_first, ForwardIt2 s_last ); | (2) | (since C++17) |

(3) | ||

template< class ForwardIt1, class ForwardIt2, class BinaryPredicate > ForwardIt1 find_first_of( ForwardIt1 first, ForwardIt1 last, ForwardIt2 s_first, ForwardIt2 s_last, BinaryPredicate p ); | (until C++11) | |

template< class InputIt, class ForwardIt, class BinaryPredicate > InputIt find_first_of( InputIt first, InputIt last, ForwardIt s_first, ForwardIt s_last, BinaryPredicate p ); | (since C++11) (until C++20) | |

template< class InputIt, class ForwardIt, class BinaryPredicate > constexpr InputIt find_first_of( InputIt first, InputIt last, ForwardIt s_first, ForwardIt s_last, BinaryPredicate p ); | (since C++20) | |

template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2, class BinaryPredicate > ForwardIt1 find_first_of( ExecutionPolicy&& policy, ForwardIt1 first, ForwardIt last, ForwardIt2 s_first, ForwardIt2 s_last, BinaryPredicate p ); | (4) | (since C++17) |

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 truefirst, 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. |

p | - | 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:
While the signature does not need to have |

Type requirements | ||

-`InputIt` must meet the requirements of LegacyInputIterator. |
||

-`ForwardIt1` must meet the requirements of LegacyForwardIterator. |
||

-`ForwardIt2` must meet the requirements of LegacyForwardIterator. |

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.

Does at most `(S*N)`

comparisons where `S = distance(s_first, s_last)`

and `N = distance(first, last)`

.

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.

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; } |

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

#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

(C++11) | finds the first element satisfying specific criteria (function template) |

© cppreference.com

Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.

http://en.cppreference.com/w/cpp/algorithm/find_first_of