◐ Shell
clean mode source ↗

std::find, std::find_if, std::find_if_not - cppreference.com

De cppreference.com

Definido en el archivo de encabezado <algorithm>

template< class InputIt, class T > InputIt find( InputIt first, InputIt last, const T& value );

 (1) (hasta C++20)

template< class InputIt, class T > constexpr InputIt find( InputIt first, InputIt last, const T& value );

 (desde C++20)

template< class ExecutionPolicy, class ForwardIt, class T > ForwardIt find( ExecutionPolicy&& policy, ForwardIt first, ForwardIt last, const T& value );

 (2) (desde C++17)

template< class InputIt, class UnaryPredicate > InputIt find_if( InputIt first, InputIt last, UnaryPredicate p );

 (3) (hasta C++20)

template< class InputIt, class UnaryPredicate > constexpr InputIt find_if( InputIt first, InputIt last, UnaryPredicate p );

 (desde C++20)

template< class ExecutionPolicy, class ForwardIt, class UnaryPredicate > ForwardIt find_if( ExecutionPolicy&& policy, ForwardIt first, ForwardIt last, UnaryPredicate p );

 (4) (desde C++17)

template< class InputIt, class UnaryPredicate > InputIt find_if_not( InputIt first, InputIt last, UnaryPredicate q );

 (5) (desde C++11)
(hasta C++20)

template< class InputIt, class UnaryPredicate > constexpr InputIt find_if_not( InputIt first, InputIt last, UnaryPredicate q );

 (desde C++20)

template< class ExecutionPolicy, class ForwardIt, class UnaryPredicate > ForwardIt find_if_not( ExecutionPolicy&& policy, ForwardIt first, ForwardIt last, UnaryPredicate q );

 (6) (desde C++17)

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

1) find busca un elemento igual a value.

3) find_if busca un elemento para el que el predicado p devuelve true.

5) find_if_not busca un elemento para el que el predicado p devuelve false.

2,4,6) Igual que (1,3,5), pero se ejecuta conforme a la política de ejecución policy. Estas sobrecargas no participan en la resolución de sobrecarga a menos que std::is_execution_policy_v<std::decay_t<ExecutionPolicy>> (hasta C++20) std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> (desde C++20) sea verdadera.

Parámetros

first, last - El rango de los elementos a examinar.
value - Valor con el que comparar los elementos.
policy - La política de ejecución a usar. Véase política de ejecución para más detalles.
p - Predicado unario que devuelve ​true para el elemento requerido.

La expresión p(v) debe ser convertible a bool para cada argumento v de tipo (posiblemente const) VT, donde VT es el tipo valor de InputIt, independientemente de la categoría de valor, y no debe modificar v. Por lo tanto, no se admite un parámetro de tipo VT&, ni es VT a menos que para VT una operación de movimiento sea equivalente a una copia (desde C++11). ​

q - Predicado unario que devuelve ​false para el elemento requerido.

La expresión q(v) debe ser convertible a bool para cada argumento v de tipo (posiblemente const) VT, donde VT es el tipo valor de InputIt, independientemente de la categoría de valor, y no debe modificar v. Por lo tanto, no se admite un parámetro de tipo VT&, ni es VT a menos que para VT una operación de movimiento sea equivalente a una copia (desde C++11). ​

Requisitos de tipo
-InputIt debe satisfacer los requisitos de InputIterator.
-ForwardIt debe satisfacer los requisitos de ForwardIterator.
-UnaryPredicate debe satisfacer los requisitos de Predicate.

Valor de retorno

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

Complejidad

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

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.

Posible implementación

Primera versió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;
}
Segunda versión 
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;
}
Tercera versión 
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;
}

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

Ejemplo

El siguiente ejemplo encuentra números enteros en un vector dado.

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

Salida: 

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

Véase también

Encuentra dos elementos contiguos idénticos (o que satisfagan un predicado dado).
(plantilla de función) [editar]
Encuentra la última secuencia de elementos en un cierto rango.
(plantilla de función) [editar]
Busca por cualquiera de un conjunto de elementos.
(plantilla de función) [editar]
Encuentra la primera posición donde dos rangos difieren.
(plantilla de función) [editar]
Busca una subsecuencia de elementos.
(plantilla de función) [editar]
Encuentra el primer elemento que satisfaga un criterio específico.
(niebloid) [editar]