std::find, std::find_if, std::find_if_not
De cppreference.com
<tbody>
</tbody>
<tbody class="t-dcl-rev t-dcl-rev-num ">
</tbody><tbody>
</tbody>
<tbody class="t-dcl-rev t-dcl-rev-num ">
</tbody><tbody>
</tbody>
<tbody class="t-dcl-rev t-dcl-rev-num ">
</tbody><tbody>
</tbody>
| Definido en el archivo de encabezado <algorithm>
|
||
| (1) | ||
template< class InputIt, class T > InputIt find( InputIt first, InputIt last, const T& value ); |
(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) |
| (3) | ||
template< class InputIt, class UnaryPredicate > InputIt find_if( InputIt first, InputIt last, UnaryPredicate p ); |
(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) |
| (5) | ||
template< class InputIt, class UnaryPredicate > InputIt find_if_not( InputIt first, InputIt last, UnaryPredicate q ); |
(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 |
| q | - | Predicado unario que devuelve false para el elemento requerido. La expresión |
| 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.
Ejecuta este código
#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) | |
| Encuentra la última secuencia de elementos en un cierto rango. (plantilla de función) | |
| Busca por cualquiera de un conjunto de elementos. (plantilla de función) | |
| Encuentra la primera posición donde dos rangos difieren. (plantilla de función) | |
| Busca una subsecuencia de elementos. (plantilla de función) | |
(C++20)(C++20)(C++20) |
Encuentra el primer elemento que satisfaga un criterio específico. (niebloid) |