Espacios de nombres
Variantes
Acciones

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

De cppreference.com
< cpp‎ | algorithm
 
 
Biblioteca de algoritmos
Políticas de ejecución (C++17)
Operaciones no modificadoras de secuencia
(C++11)(C++11)(C++11)
(C++17)
findfind_iffind_if_not
(C++11)
Operaciones modificadoras de secuencia
Operaciones en almacenamiento no inicializado
Operaciones de partición
Operaciones de ordenación
(C++11)
Operaciones de búsqueda binaria
Operaciones de set (en rangos ordenados)
Operaciones de pila
(C++11)
Operaciones minimo/maximo
(C++11)
(C++17)
Permutaciones
Operaciones numéricas
Bibliotecas C
 
Definido en la cabecera <algorithm>
(1)
template< class InputIt, class T >
InputIt find( InputIt primero, InputIt ultimo, const T& valor );
(hasta C++20)
template< class InputIt, class T >
constexpr InputIt find( InputIt primero, InputIt ultimo, const T& valor );
(desde C++20)
template< class ExecutionPolicy, class ForwardIt, class T >

ForwardIt find( PoliticaEjecucion&& politica, ForwardIt primero, ForwardIt ultimo,

                const T& valor );
(2) (desde C++17)
(3)
template< class InputIt, class PredicadoUnario >

InputIt find_if( InputIt primero, InputIt ultimo,

                 PredicadoUnario p );
(hasta C++20)
template< class InputIt, class PredicadoUnario >

constexpr InputIt find_if( InputIt primero, InputIt ultimo,

                           PredicadoUnario p );
(desde C++20)
template< class PoliticaEjecucion, class ForwardIt, class PredicadoUnario >

ForwardIt find_if( PoliticaEjecucion&& politica, ForwardIt primero, ForwardIt last,

                 PredicadoUnario p );
(4) (desde C++17)
(5)
template< class InputIt, class PredicadoUnario >

InputIt find_if_not( InputIt primero, InputIt last,

                     PredicadoUnario q );
(desde C++11)
(hasta C++20)
template< class InputIt, class PredicadoUnario >

constexpr InputIt find_if_not( InputIt primero, InputIt last,

                               PredicadoUnario q );
(desde C++20)
template< class PoliticaEjecucion, class ForwardIt, class PredicadoUnario >

ForwardIt find_if_not( PoliticaEjecucion&& politica, ForwardIt primero, ForwardIt last,

                     PredicadoUnario q );
(6) (desde C++17)

Devuelve el primero elemento en el rango [primero, ultimo) el cual satisface criterios específicos:

1) find busca un elemento igual a valor
3) find_if busca un elemento para el cual el predicado p devuelve true
5) find_if_not busca un elemento para el cual el predicado q devuelve false
2,4,6) Igual que (1,3,5), pero ejecutado de acuerdo con politica. Esta sobrecarga solo participa en la resolución de sobrecargas si std::is_execution_policy_v<std::decay_t<PoliticaEjecucion>> is true

Contenido

[editar] Parametros

primero, ultimo - el rango de elementos a examinar
valor - valor al que comparar los elementos
política - la política de ejecución que usar.
p - predicado unario que devuelve ​true para el elemento requerido.

La firma de la función predicado debe ser equivalente a:

 bool pred(const Type &a);

La forma no necesita tener const &, pero la función no debe modificar el objeto que ha sido pasado.
El tipo Type debe ser tal que un objeto del tipo InputIt puede ser derreferenciado y entonces convertido implícitamente a Type. ​

q - predicado unario que devuelve ​true para el elemento requerido.

La firma de la función predicado debe ser equivalente a:

 bool pred(const Type &a);

La forma no necesita tener const &, pero la función no debe modificar el objeto que ha sido pasado.
El tipo Type debe ser tal que un objeto del tipo InputIt puede ser derreferenciado y entonces convertido implícitamente a Type. ​

Requerimientos de tipo
-
InputIt debe reunir los requerimientos de InputIterator.
-
ForwardIt debe reunir los requerimientos de ForwardIterator.
-
PredicadoUnario debe reunir los requerimientos de Predicate.

[editar] Valor devuelto

Iterador al primer elemento que satisface la condición o ultimo si tal elemento no se encuentra.

[editar] Complejidad

Como mucho ultimo - primero aplicaciones del predicado

[editar] Excepciones

Las sobrecargas con un parámetro de plantilla llamado PoliticaEjecucion reportan errores tal que:

  • Si la ejecución de una función invocada como parte del algoritmo lanza una excepción y la PoliticaEjecucion es una de las tres políticas estandar, std::terminate es llamado. Para cualquier otra PoliticaEjecucion, el comportamiento es definido por la implementación.
  • Si el algoritmo falla al alocar memoria, std::bad_alloc es lanzado.

[editar] Posibles implementaciones

Primera versión
template<class InputIt, class T>
InputIt find(InputIt primero, InputIt ultimo, const T& value)
{
    for (; primero != ultimo; ++primero) {
        if (*primero == value) {
            return primero;
        }
    }
    return ultimo;
}
Segunda versión
template<class InputIt, class PredicadoUnario>
InputIt find_if(InputIt primero, InputIt ultimo, PredicadoUnario p)
{
    for (; primero != ultimo; ++primero) {
        if (p(*primero)) {
            return primero;
        }
    }
    return ultimo;
}
Tercera versión
template<class InputIt, class PredicadoUnario>
InputIt find_if_not(InputIt primero, InputIt ultimo, PredicadoUnario q)
{
    for (; primero != ultimo; ++primero) {
        if (!q(*primero)) {
            return primero;
        }
    }
    return ultimo;
}

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

template<class InputIt, class PredicadoUnario>
InputIt find_if_not(InputIt primero, InputIt ultimo, PredicadoUnario q)
{
    return std::find_if(primero, ultimo, std::not1(q));
}

[editar] Ejemplo

El siguiente ejemplo encuentra un entero en un vector de enteros.

#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 resultado1 = std::find(std::begin(v), std::end(v), n1);
    auto resultado2 = std::find(std::begin(v), std::end(v), n2);
 
    if (resultado1 != std::end(v)) {
        std::cout << "v contiene: " << n1 << '\n';
    } else {
        std::cout << "v no contiene: " << n1 << '\n';
    }
 
    if (resultado2 != std::end(v)) {
        std::cout << "v contiene: " << n2 << '\n';
    } else {
        std::cout << "v no contiene: " << n2 << '\n';
    }
}

Salida:

v contiene: 3
v no contiene: 5

[editar] Ver también

encuentra dos elementos contiguos idénticos (o que satisfacen un predicado)
(plantilla de función) [editar]
encuentra la última secuencia de elementos en un cierto rango
Original:
finds the last sequence of elements in a certain range
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(plantilla de función) [editar]
busca cualquiera de los elementos de un set
(plantilla de función) [editar]
encuentra la primera posición donde dos rangos difieren
(plantilla de función) [editar]
busca a un rango de elementos
(plantilla de función) [editar]