std::ranges::all_of, std::ranges::any_of, std::ranges::none_of - 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, 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

#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

Comprueba si un predicado es true para todos, alguno o ninguno de los elementos de un rango.
(plantilla de función) [editar]