std::all_of, std::any_of, std::none_of

Definido en el archivo de encabezado `<algorithm>`
	(1)
`template< class InputIt, class UnaryPredicate > bool all_of( InputIt first, InputIt last, UnaryPredicate p );`			(desde C++11) (hasta C++20)
`template< class InputIt, class UnaryPredicate > constexpr bool all_of( InputIt first, InputIt last, UnaryPredicate p );`			(desde C++20)
`template< class ExecutionPolicy, class ForwardIt, class UnaryPredicate > bool all_of( ExecutionPolicy&& policy, ForwardIt first, ForwardIt last, UnaryPredicate p );`		(2)	(desde C++17)
		(3)
`template< class InputIt, class UnaryPredicate > bool any_of( InputIt first, InputIt last, UnaryPredicate p );`				(desde C++11) (hasta C++20)
`template< class InputIt, class UnaryPredicate > constexpr bool any_of( InputIt first, InputIt last, UnaryPredicate p );`				(desde C++20)
`template< class ExecutionPolicy, class ForwardIt, class UnaryPredicate > bool any_of( ExecutionPolicy&& policy, ForwardIt first, ForwardIt last, UnaryPredicate p );`			(4)	(desde C++17)
			(5)
`template< class InputIt, class UnaryPredicate > bool none_of( InputIt first, InputIt last, UnaryPredicate p );`					(desde C++11) (hasta C++20)
`template< class InputIt, class UnaryPredicate > constexpr bool none_of( InputIt first, InputIt last, UnaryPredicate p );`					(desde C++20)
`template< class ExecutionPolicy, class ForwardIt, class UnaryPredicate > bool none_of( ExecutionPolicy&& policy, ForwardIt first, ForwardIt last, UnaryPredicate p );`				(6)	(desde C++17)

1) Verifica si el predicado unario p devuelve true para todos los elements en el rango [first, last).

3) Verifica si el predicado unario p devuelve true para al menos un elemento en el rango [first, last).

5) Verifica si el predicado unario p devuelve true para ningún elemento en el rango [first, last).

2,4,6) Igual que (1,3,5), pero ejecutado de acuerdo 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 elementos a examinar.
policy	-	La política de ejecución a usar. Véase política de ejecución para más detalles.
p	-	Predicado unario . See More La expresión `p(v)` debe ser convertible a `bool` para cada argumento `v` de tipo (posiblemente `const`) `VT`, donde `VT` es el tipo valor de `InputIt`, independientemente de la categoría de valor, y no debe modificar `v`. Por lo tanto, no se admite un parámetro de tipo `VT&`, ni es `VT` a menos que para `VT` una operación de movimiento sea equivalente a una copia (desde C++11).
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

Véase también la sección de Notas más abajo.

1-2) true si el predicado unario p devuelve true para todos los elements en el rango, false de lo contrario. Devuelve true si el rango está vacío.

3-4) true si el predicado unario p devuelve true para al menos un elemento en el rango, false de lo contrario. Devuelve false si el rango está vacío.

5-6) true si el predicado unario p devuelve true para ningún elemento en el rango, false de lo contrario. Devuelve true si el rango está vacío.

Complejidad

1,3,5) A lo sumo last - first aplicaciones del predicado.

2,4,6)

O(last-first)

aplicaciones del predicado.

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

Véanse también las implementaciones de all_of en libstdc++ y libc++.

Véanse también las implementaciones de any_of en libstdc++ y libc++.

Véanse también las implementaciones de none_of en libstdc++ y libc++.

Primera versión
template< class InputIt, class UnaryPredicate > constexpr bool all_of(InputIt first, InputIt last, UnaryPredicate p) { return std::find_if_not(first, last, p) == last; }
Segunda versión
template< class InputIt, class UnaryPredicate > constexpr bool any_of(InputIt first, InputIt last, UnaryPredicate p) { return std::find_if(first, last, p) != last; }
Tercera versión
template< class InputIt, class UnaryPredicate > constexpr bool none_of(InputIt first, InputIt last, UnaryPredicate p) { return std::find_if(first, last, p) == last; }

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>
 
int main()
{
    std::vector<int> v(10, 2);
    std::partial_sum(v.cbegin(), v.cend(), v.begin());
    std::cout << "Entre los números: ";
    std::copy(v.cbegin(), v.cend(), std::ostream_iterator<int>(std::cout, " "));
    std::cout << '\n';

    if (std::all_of(v.cbegin(), v.cend(), [](int i){ return i % 2 == 0; })) {
        std::cout << "Todos los números son pares\n";
    }
    if (std::none_of(v.cbegin(), v.cend(), std::bind(std::modulus<>(), 
                                                     std::placeholders::_1, 2))) {
        std::cout << "Ninguno es non\n";
    }
    struct DivisibleBy
    {
        const int d;
        DivisibleBy(int n) : d(n) {}
        bool operator()(int n) const { return n % d == 0; }
    };

    if (std::any_of(v.cbegin(), v.cend(), DivisibleBy(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

ranges::all_ofranges::any_ofranges::none_of

(C++20)(C++20)(C++20)

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

Apoyo de compiladores
Implementaciones independientes y albergadas
Lenguaje
Biblioteca estándar
Encabezados de la biblioteca estándar
Requisitos denominados
Macros de prueba de característica (C++20)
Biblioteca de apoyo del lenguaje
Biblioteca de conceptos (C++20)
Biblioteca de diagnósticos
Biblioteca de gestión de memoria
Biblioteca de metaprogramación (C++11)
Biblioteca de servicios generales
Biblioteca de contenedores
Biblioteca de iteradores
Biblioteca de rangos (C++20)
Biblioteca de algoritmos
Biblioteca de cadenas
Biblioteca de procesamiento de texto
Biblioteca numérica
Biblioteca de fecha y hora
Biblioteca de entrada/salida
Biblioteca del sistema de archivos (C++17)
Biblioteca de apoyo de concurrencia (C++11)
Biblioteca de apoyo de ejecución (C++26)
Especificaciones técnicas
Índice de símbolos
Bibliotecas externas

cppreference.com

Buscar

Espacios de nombres

Variantes

Vistas

Acciones