| Defined in header <algorithm> | ||
|---|---|---|
template< class InputIt, class T > InputIt find( InputIt first, InputIt last, const T& value ); | (1) | |
template< class InputIt, class UnaryPredicate >
InputIt find_if( InputIt first, InputIt last,
UnaryPredicate p ); | (2) | |
template< class InputIt, class UnaryPredicate >
InputIt find_if_not( InputIt first, InputIt last,
UnaryPredicate q ); | (3) | (since C++11) |
Returns the first element in the range [first, last) that satisfies specific criteria:
find searches for an element equal to value find_if searches for an element for which predicate p returns true find_if_not searches for an element for which predicate q returns false Parameters
| first, last | - | the range of elements to examine |
| value | - | value to compare the elements to |
| p | - | unary predicate which returns true for the required element. The signature of the predicate function should be equivalent to the following:
The signature does not need to have |
| q | - | unary predicate which returns false for the required element. The signature of the predicate function should be equivalent to the following:
The signature does not need to have |
| Type requirements | ||
- InputIt must meet the requirements of InputIterator. | ||
- UnaryPredicate must meet the requirements of Predicate. | ||
Return value
Iterator to the first element satisfying the condition or last if no such element is found.
Complexity
At most last - first applications of the predicate.
Possible implementation
| First version |
|---|
template<class InputIt, class T>
InputIt find(InputIt first, InputIt last, const T& value)
{
for (; first != last; ++first) {
if (*first == value) {
return first;
}
}
return last;
} |
| Second version |
template<class InputIt, class UnaryPredicate>
InputIt find_if(InputIt first, InputIt last, UnaryPredicate p)
{
for (; first != last; ++first) {
if (p(*first)) {
return first;
}
}
return last;
} |
| Third version |
template<class InputIt, class UnaryPredicate>
InputIt find_if_not(InputIt first, InputIt last, UnaryPredicate q)
{
for (; first != last; ++first) {
if (!q(*first)) {
return first;
}
}
return last;
} |
If you do not have C++11, an equivalent to std::find_if_not is to use std::find_if with the negated predicate.
template<class InputIt, class UnaryPredicate>
InputIt find_if_not(InputIt first, InputIt last, UnaryPredicate q)
{
return std::find_if(first, last, std::not1(q));
} |
Example
The following example finds an integer in a vector of integers.
#include <iostream>
#include <algorithm>
#include <vector>
#include <iterator>
int main()
{
int n1 = 3;
int n2 = 5;
std::vector<int> v{0, 1, 2, 3, 4};
auto result1 = std::find(std::begin(v), std::end(v), n1);
auto result2 = std::find(std::begin(v), std::end(v), n2);
if (result1 != std::end(v)) {
std::cout << "v contains: " << n1 << '\n';
} else {
std::cout << "v does not contain: " << n1 << '\n';
}
if (result2 != std::end(v)) {
std::cout << "v contains: " << n2 << '\n';
} else {
std::cout << "v does not contain: " << n2 << '\n';
}
}Output:
v contains: 3 v does not contain: 5
See also
| finds the first two adjacent items that are equal (or satisfy a given predicate) (function template) | |
| finds the last sequence of elements in a certain range (function template) | |
| searches for any one of a set of elements (function template) | |
| finds the first position where two ranges differ (function template) | |
| searches for a range of elements (function template) | |
| std::experimental::parallel::find
(parallelism TS) | parallelized version of std::find (function template) |
| std::experimental::parallel::find_if
(parallelism TS) | parallelized version of std::find_if (function template) |
| std::experimental::parallel::find_if_not
(parallelism TS) | parallelized version of std::find_if_not (function template) |
Please login to continue.