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

(1) | ||

template< class InputIt, class ForwardIt > InputIt find_first_of( InputIt first, InputIt last, ForwardIt s_first, ForwardIt s_last ); | (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 InputIt, class ForwardIt, class BinaryPredicate > InputIt find_first_of( InputIt first, InputIt last, ForwardIt s_first, ForwardIt s_last, BinaryPredicate p ); | (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`

`)`

.

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
| (until C++20) |

| (since C++20) |

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

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

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

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

-`BinaryPredicate` must meet the requirements of BinaryPredicate. |

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.

Given `N`

as `std::distance(first, last)`

and `S`

as `std::distance(s_first, s_last)`

:

operator==

3,4) At most

`N·S`

applications of the predicate `p`

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.

find_first_of (1) |
---|

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

find_first_of (3) |

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 }

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

DR | Applied to | Behavior as published | Correct behavior |
---|---|---|---|

LWG 576 | C++98 | `first` and `last` needed to be LegacyForwardIterators | they only need to be LegacyInputIterators |

(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