std::find, std::find_if, std::find_if_not

Devuelve un iterador al primer elemento en el rango [first, last) que satisface criterios específicos:

[editar] Parámetros

[editar] Valor de retorno

Iterador al primer elemento que cumple la condición o un iterador igual a last si no se encuentra dicho elemento.

[editar] Complejidad

A lo sumo N aplicaciones del predicado, donde N = std::distance(first, last).

[editar] Excepciones

Las sobrecargas con un parámetro de plantilla llamado ExecutionPolicy (política de ejecución) reportan errores tales que:

• Si la ejecución de una función invocada como parte del algoritmo lanza una excepción y la política de ejecución es una de las tres políticas estándar, se llama a std::terminate. Para cualquier otra política de ejecución, el comportamiento está definido por la implementación.
• Si el algoritmo falla al asignar memoria, se lanza std::bad_alloc.

[editar] Posible implementación

template<class InputIt, class T>
constexpr InputIt find(InputIt first, InputIt last, const T& value)
{
    for (; first != last; ++first) {
        if (*first == value) {
            return first;
        }
    }
    return last;
}

template<class InputIt, class UnaryPredicate>
constexpr InputIt find_if(InputIt first, InputIt last, UnaryPredicate p)
{
    for (; first != last; ++first) {
        if (p(*first)) {
            return first;
        }
    }
    return last;
}

template<class InputIt, class UnaryPredicate>
constexpr InputIt find_if_not(InputIt first, InputIt last, UnaryPredicate q)
{
    for (; first != last; ++first) {
        if (!q(*first)) {
            return first;
        }
    }
    return last;
}

[editar] Notas

Si no tienes C++11, un equivalente a std::find_if_not es usar std::find_if con el predicado negado.

template<class InputIt, class UnaryPredicate>
InputIt find_if_not(InputIt first, InputIt last, UnaryPredicate q)
{
    return std::find_if(first, last, std::not1(q));
}

[editar] Ejemplo

#include <iostream>
#include <algorithm>
#include <vector>
#include <iterator>
 
int main()
{
    std::vector<int> v{1, 2, 3, 4};
    int n1 = 3;
    int n2 = 5;
    auto es_par = [](int i){ return i%2 == 0; };
 
    auto resultado1 = std::find(begin(v), end(v), n1);
    auto resultado2 = std::find(begin(v), end(v), n2);
    auto resultado3 = std::find_if(begin(v), end(v), es_par);
 
    (resultado1 != std::end(v))
        ? std::cout << "v contiene " << n1 << '\n'
        : std::cout << "v no contiene " << n1 << '\n';
 
    (resultado2 != std::end(v))
        ? std::cout << "v contiene " << n2 << '\n'
        : std::cout << "v no contiene " << n2 << '\n';
 
    (resultado3 != std::end(v))
        ? std::cout << "v contiene un número par: " << *resultado3 << '\n'
        : std::cout << "v no contiene números pares\n";
}

v contiene 3
v no contiene 5
v contiene un número par: 2

[editar] Véase también