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`

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

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 = std::distance(s_first, s_last)`

and `N = std::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> auto print_sequence = [](auto const id, auto const& seq, int pos = -1) { std::cout << id << "{ "; for (int i{}; auto const& e : seq) { const bool mark {i == pos}; std::cout << (i++ ? ", " : ""); std::cout << (mark ? ">> " : "") << e << (mark ? " <<" : ""); } std::cout << " }\n"; }; int main() { const std::vector<int> v{0, 2, 3, 25, 5}; const auto t1 = {19, 10, 3, 4}; const auto t2 = {1, 6, 7, 9}; auto find_any_of = [](const auto& v, const auto& t) { const auto result = std::find_first_of(v.begin(), v.end(), t.begin(), t.end()); if (result == v.end()) { std::cout << "No elements of v are equal to any element of "; print_sequence("t = ", t); print_sequence("v = ", v); } else { const auto pos = std::distance(v.begin(), result); std::cout << "Found a match (" << *result << ") at position " << pos; print_sequence(", where t = ", t); print_sequence("v = ", v, pos); } }; find_any_of(v, t1); find_any_of(v, t2); }

Output:

Found a match (3) at position 2, where t = { 19, 10, 3, 4 } v = { 0, 2, >> 3 <<, 25, 5 } No elements of v are equal to any element of t = { 1, 6, 7, 9 } v = { 0, 2, 3, 25, 5 }

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

(C++20) | searches for any one of a set of elements (niebloid) |

© cppreference.com

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

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