std::ranges::all_of, std::ranges::any_of, std::ranges::none_of
De cppreference.com
<tbody>
</tbody>
| 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, std::indirect_unary_predicate<std::projected<I, Proj>> Pred > constexpr bool all_of( I first, S last, Pred pred, Proj proj = {} ); |
(1) | (desde C++20) |
template< ranges::input_range R, class Proj = std::identity, std::indirect_unary_predicate< std::projected<ranges::iterator_t<R>,Proj>> Pred > constexpr bool all_of( R&& r, Pred pred, Proj proj = {} ); |
(2) | (desde C++20) |
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 any_of( I first, S last, Pred pred, Proj proj = {} ); |
(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 > constexpr bool any_of( R&& r, Pred pred, Proj proj = {} ); |
(4) | (desde C++20) |
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 none_of( I first, S last, Pred pred, Proj proj = {} ); |
(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 > constexpr bool none_of( R&& r, Pred pred, Proj proj = {} ); |
(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.
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. |
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.Complejidad
A lo sumo last - first aplicaciones del predicado y la proyección.
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;
|
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
|
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
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) |