std::ranges::find, std::ranges::find_if, std::ranges::find_if_not
De cppreference.com
Definido en el archivo de encabezado <algorithm> | ||
Signatura de la llamada | ||
template<std::input_iterator I, std::sentinel_for<I> S, class T, class Proj =std::identity> | (1) | (desde C++20) |
template<ranges::input_range R, class T, class Proj =std::identity> requires std::indirect_binary_predicate<ranges::equal_to, | (2) | (desde C++20) |
template<std::input_iterator I, std::sentinel_for<I> S, class Proj =std::identity, | (3) | (desde C++20) |
template<ranges::input_range R, class Proj =std::identity, std::indirect_unary_predicate<std::projected<ranges::iterator_t<R>, Proj>> Pred > | (4) | (desde C++20) |
template<std::input_iterator I, std::sentinel_for<I> S, class Proj =std::identity, | (5) | (desde C++20) |
template<ranges::input_range R, class Proj =std::identity, std::indirect_unary_predicate<std::projected<ranges::iterator_t<R>, Proj>> Pred > | (6) | (desde C++20) |
Devuelve el 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 pred devuelve true.5)
find_if_not busca un elemento para el que el predicado pred devuelve false.2,4,6) Igual que (1,3,5), pero usa
r como el rango fuente, como si usara ranges::begin(r) como first y ranges::end(r) como last.Las entidades similares a funciones descritas en esta página son niebloids, es decir:
- Las listas de argumentos de plantilla explícitas no se pueden especificar al llamar a cualquiera de ellas.
- Ninguna de ellas es visible para la búsqueda dependiente de argumentos.
- Cuando alguna de ellas se encuentra mediante la búsqueda normal no calificada como el nombre a la izquierda del operador de llamada a función, se inhibe la búsqueda dependiente de argumentos.
En la práctica, pueden implementarse como objetos función o con extensiones de compilador especiales.
Contenido |
[editar]Parámetros
| first, last | - | El rango de los elementos a examinar. |
| r | - | El rango de los elementos a examinar. |
| value | - | Valor con el que comparar los elementos. |
| pred | - | Predicado a aplicar a los elementos proyectados. |
| proj | - | Proyección a aplicar a los elementos. |
[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 last - first aplicaciones del predicado y la proyección.
[editar]Posible implementación
| Primera versión |
|---|
struct find_fn {template<std::input_iterator I, std::sentinel_for<I> S, class T, class Proj =std::identity> requires std::indirect_binary_predicate<ranges::equal_to, std::projected<I, Proj>, const T*>constexpr I operator()( I first, S last, const T& value, Proj proj ={})const{for(; first != last;++first){if(std::invoke(proj, *first)== value){return first;}}return first;} template<ranges::input_range R, class T, class Proj =std::identity> requires std::indirect_binary_predicate<ranges::equal_to, std::projected<ranges::iterator_t<R>, Proj>, const T*>constexprranges::borrowed_iterator_t<R> operator()( R&& r, const T& value, Proj proj ={})const{return(*this)(ranges::begin(r), ranges::end(r), value, std::ref(proj));}}; inlineconstexpr find_fn find; |
| Segunda versión |
struct find_if_fn {template<std::input_iterator I, std::sentinel_for<I> S, class Proj =std::identity, std::indirect_unary_predicate<std::projected<I, Proj>> Pred >constexpr I operator()( I first, S last, Pred pred, Proj proj ={})const{for(; first != last;++first){if(std::invoke(pred, std::invoke(proj, *first))){return first;}}return first;} template<ranges::input_range R, class Proj =std::identity, std::indirect_unary_predicate<std::projected<ranges::iterator_t<R>, Proj>> Pred >constexprranges::borrowed_iterator_t<R> operator()( R&& r, Pred pred, Proj proj ={})const{return(*this)(ranges::begin(r), ranges::end(r), std::ref(pred), std::ref(proj));}}; inlineconstexpr find_if_fn find_if; |
| Tercera versión |
struct find_if_not_fn {template<std::input_iterator I, std::sentinel_for<I> S, class Proj =std::identity, std::indirect_unary_predicate<std::projected<I, Proj>> Pred >constexpr I operator()( I first, S last, Pred pred, Proj proj ={})const{for(; first != last;++first){if(!std::invoke(pred, std::invoke(proj, *first))){return first;}}return first;} template<ranges::input_range R, class Proj =std::identity, std::indirect_unary_predicate<std::projected<ranges::iterator_t<R>, Proj>> Pred >constexprranges::borrowed_iterator_t<R> operator()( R&& r, Pred pred, Proj proj ={})const{return(*this)(ranges::begin(r), ranges::end(r), std::ref(pred), std::ref(proj));}}; inlineconstexpr find_if_not_fn find_if_not; |
[editar]Ejemplo
Ejecuta este código
#include <algorithm>#include <iostream>#include <iterator> int main(){namespace ranges = std::ranges; constint n1 =3;constint n2 =5;constauto v ={4, 1, 3, 2}; if(ranges::find(v, n1)!= v.end()){std::cout<<"v contiene: "<< n1 <<'\n';}else{std::cout<<"v no contiene: "<< n1 <<'\n';} if(ranges::find(v.begin(), v.end(), n2)!= v.end()){std::cout<<"v contiene: "<< n2 <<'\n';}else{std::cout<<"v no contiene: "<< n2 <<'\n';} auto es_par =[](int x){return x %2==0;}; if(auto resultado = ranges::find_if(v.begin(), v.end(), es_par); resultado != v.end()){std::cout<<"Primer elemento par en v: "<<*resultado <<'\n';}else{std::cout<<"No hay elementos pares en v\n";} if(auto resultado = ranges::find_if_not(v, es_par); resultado != v.end()){std::cout<<"Primer elemento non en v: "<<*resultado <<'\n';}else{std::cout<<"No hay elementos nones en v\n";} auto se_divide_por_13 =[](int x){return x %13==0;}; if(auto resultado = ranges::find_if(v, se_divide_por_13); resultado != v.end()){std::cout<<"Primer elemento divisible por 13 en v: "<<*resultado <<'\n';}else{std::cout<<"No hay elementos en v divisibles por 13\n";} if(auto resultado = ranges::find_if_not(v.begin(), v.end(), se_divide_por_13); resultado != v.end()){std::cout<<"Primer elemento no divisible por 13 en v: "<<*resultado <<'\n';}else{std::cout<<"Todos los elementos en v son divisibles por 13\n";}}
Salida:
v contiene: 3 v no contiene: 5 Primer elemento par en v: 4 Primer elemento non en v: 1 No hay elementos en v divisibles por 13 Primer elemento no divisible por 13 en v: 4
[editar]Véase también
(C++20) | Encuentra dos primeros elementos contiguos idénticos (o que satisfagan un predicado dado). (niebloid) |
(C++20) | Encuentra la última secuencia de elementos en un cierto rango. (niebloid) |
(C++20) | Busca por cualquiera de un conjunto de elementos. (niebloid) |
(C++20) | Encuentra la primera posición donde dos rangos difieren. (niebloid) |
(C++20) | Busca una subsecuencia de elementos en un rango. (niebloid) |
(C++11) | Encuentra el primer elemento que satisfaga un criterio específico. (plantilla de función) |
