std::all_of, std::any_of, std::none_of - cppreference.com

</tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody>

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

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++.

template< class InputIt, class UnaryPredicate >
constexpr bool all_of(InputIt first, InputIt last, UnaryPredicate p)
{
    return std::find_if_not(first, last, p) == last;
}

template< class InputIt, class UnaryPredicate >
constexpr bool any_of(InputIt first, InputIt last, UnaryPredicate p)
{
    return std::find_if(first, last, p) != last;
}

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:

Ejemplo

#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";
    }
}

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