std::ranges::all_of, std::ranges::any_of, std::ranges::none_of
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 Proj = std::identity, | (1) | (desde C++20) |
template< ranges::input_range R, class Proj = std::identity, std::indirect_unary_predicate< | (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< | (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< | (6) | (desde C++20) |
1) Verifica si el predicado unario
pred devuelve true para todos los elements en el rango [first, last) (después de proyectar con la proyección proj).3) Verifica si el predicado unario
pred devuelve true para al menos un elemento en el rango [first, last) (después de proyectar con la proyección proj).5) Verifica si el predicado unario
pred devuelve true para ningún elemento en el rango [first, last) (después de proyectar con la proyección proj).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 elementos a examinar. |
| r | - | El rango de elementos a examinar. |
| pred | - | El predicado a aplicar a los elementos proyectados. |
| proj | - | La proyección a aplicar a los elementos. |
[editar] Valor de retorno
Véase también la sección de Notas más abajo.
1-2) true si std::invoke(pred, std::invoke(proj, *i)) != false para cada iterador
i en el rango, false de lo contrario. Devuelve true si el rango está vacío.3-4) true si std::invoke(pred, std::invoke(proj, *i)) != false para al menos un iterador
i en el rango, false de lo contrario. Devuelve false si el rango está vacío.5-6) true si std::invoke(pred, std::invoke(proj, *i)) == false para cada iterador
i en el rango, false de lo contrario. Devuelve true si el rango está vacío.[editar] Complejidad
A lo sumo last - first aplicaciones del predicado y la proyección.
[editar] Posible implementación
| Primera versión |
|---|
struct all_of_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 bool operator()( I first, S last, Pred pred, Proj proj = {} ) const { return ranges::find_if_not(first, last, std::ref(pred), std::ref(proj)) == last; } template< ranges::input_range R, class Proj = std::identity, std::indirect_unary_predicate< std::projected<ranges::iterator_t<R>,Proj>> Pred > constexpr bool operator()( R&& r, Pred pred, Proj proj = {} ) const { return operator()(ranges::begin(r), ranges::end(r), std::ref(pred), std::ref(proj)); } }; inline constexpr all_of_fn all_of; |
| Segunda versión |
struct any_of_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 bool operator()( I first, S last, Pred pred, Proj proj = {} ) const { return ranges::find_if(first, last, std::ref(pred), std::ref(proj)) != last; } template< ranges::input_range R, class Proj = std::identity, std::indirect_unary_predicate< std::projected<ranges::iterator_t<R>,Proj>> Pred > constexpr bool operator()( R&& r, Pred pred, Proj proj = {} ) const { return operator()(ranges::begin(r), ranges::end(r), std::ref(pred), std::ref(proj)); } }; inline constexpr any_of_fn any_of; |
| Tercera versión |
struct none_of_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 bool operator()( I first, S last, Pred pred, Proj proj = {} ) const { return ranges::find_if(first, last, std::ref(pred), std::ref(proj)) == last; } template< ranges::input_range R, class Proj = std::identity, std::indirect_unary_predicate< std::projected<ranges::iterator_t<R>,Proj>> Pred > constexpr bool operator()( R&& r, Pred pred, Proj proj = {} ) const { return operator()(ranges::begin(r), ranges::end(r), std::ref(pred), std::ref(proj)); } }; inline constexpr none_of_fn none_of; |
[editar] Notas
El valor de retorno representado en la forma de la tabla de verdad es:
| El rango de entrada contiene | ||||
|---|---|---|---|---|
| todos true, ninguno false | algunos true, algunos false | ninguno true, todos false | ninguno true, ninguno false (rango vacío) | |
| 1–2) all_of | true | false | false | true |
| 3–4) any_of | true | true | false | false |
| 5–6) none_of | false | false | true | true |
[editar] Ejemplo
Ejecuta este código
#include <vector> #include <numeric> #include <algorithm> #include <iterator> #include <iostream> #include <functional> namespace ranges = std::ranges; int main() { std::vector<int> v(10, 2); std::partial_sum(v.cbegin(), v.cend(), v.begin()); std::cout << "Entre los números: "; ranges::copy(v, std::ostream_iterator<int>(std::cout, " ")); std::cout << '\n'; if (ranges::all_of(v.cbegin(), v.cend(), [](int i){ return i % 2 == 0; })) { std::cout << "Todos los números son pares\n"; } if (ranges::none_of(v, std::bind(std::modulus<int>(), std::placeholders::_1, 2))) { std::cout << "Ninguno es non\n"; } auto DivisiblePor = [](int d) { return [d](int m) { return m % d == 0; }; }; if (ranges::any_of(v, DivisiblePor(7))) { std::cout << "Al menos un número es divisible por 7\n"; } }
Salida:
Entre los números: 2 4 6 8 10 12 14 16 18 20 Todos los números son pares Ninguno es non Al menos un número es divisible por 7
[editar] Véase también
(C++11)(C++11)(C++11) | Comprueba si un predicado es true para todos, alguno o ninguno de los elementos de un rango. (plantilla de función) |
