Espacios de nombres
Variantes
Acciones

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

De cppreference.com
< cpp‎ | algorithm

 
 
Biblioteca de algoritmos
Políticas de ejecución (C++17)
Operaciones no modificadoras de secuencia
all_ofany_ofnone_of
(C++11)(C++11)(C++11)
(C++17)
Operaciones modificadoras de secuencia
Operaciones en almacenamiento no inicializado
Operaciones de partición
Operaciones de ordenación
(C++11)
Operaciones de búsqueda binaria
Operaciones de set (en rangos ordenados)
Operaciones de pila
(C++11)
Operaciones minimo/maximo
(C++11)
(C++17)
Permutaciones
Operaciones numéricas
Bibliotecas C
 
Definido en la cabecera <algorithm>
template< class InputIt, class UnaryPredicate >
bool all_of( InputIt first, InputIt last, UnaryPredicate p );
(1) (desde C++11)
template< class InputIt, class UnaryPredicate >
bool any_of( InputIt first, InputIt last, UnaryPredicate p );
(2) (desde C++11)
template< class InputIt, class UnaryPredicate >
bool none_of( InputIt first, InputIt last, UnaryPredicate p );
(3) (desde C++11)
1)
Comprueba si predicado unario p vuelve true para todos los elementos en el rango [first, last) .
Original:
Checks if unary predicate p returns true for all elements in the range [first, last).
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
2)
Comprueba si predicado unario p vuelve true para al menos un elemento en el rango [first, last) .
Original:
Checks if unary predicate p returns true for at least one element in the range [first, last).
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
3)
Comprueba si predicado unario p vuelve true de ningún elemento en el rango [first, last) .
Original:
Checks if unary predicate p returns true for no elements in the range [first, last).
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Contenido

[editar] Parámetros

first, last -
la gama de elementos a examinar
Original:
the range of elements to examine
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
p - predicado unario .

La firma de la función predicado debe ser equivalente a:

 bool pred(const Type &a);

La forma no necesita tener const &, pero la función no debe modificar el objeto que ha sido pasado.
El tipo Type debe ser tal que un objeto del tipo InputIt puede ser derreferenciado y entonces convertido implícitamente a Type. ​

Requerimientos de tipo
-
InputIt debe reunir los requerimientos de InputIterator.

[editar] Valor de retorno

1)
true si predicado unario true retornos para todos los elementos de la gama, false lo contrario. Devoluciones true si el rango está vacío .
Original:
true if unary predicate returns true for all elements in the range, false otherwise. Returns true if the range is empty.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
2)
true si predicado unario true rendimientos de al menos un elemento en el intervalo, false lo contrario. Devoluciones false si el rango está vacío .
Original:
true if unary predicate returns true for at least one element in the range, false otherwise. Returns false if the range is empty.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
3)
true si predicado unario true vuelve a ningún elemento de la gama, false lo contrario. Devoluciones true si el rango está vacío .
Original:
true if unary predicate returns true for no elements in the range, false otherwise. Returns true if the range is empty.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[editar] Complejidad

A lo sumo last - first aplicaciones del predicado
Original:
At most last - first applications of the predicate
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[editar] Posible implementación

Primera versión
template< class InputIt, class UnaryPredicate >
bool all_of(InputIt first, InputIt last, UnaryPredicate p)
{
    for (; first != last; ++first) {
        if (!p(*first)) return false;
    }
    return true;
}
Segunda versión
template< class InputIt, class UnaryPredicate >
bool any_of(InputIt first, InputIt last, UnaryPredicate p)
{
    for (; first != last; ++first) {
        if (p(*first)) return true;
    }
    return false;
}
Tercera versión
template< class InputIt, class UnaryPredicate >
bool none_of(InputIt first, InputIt last, UnaryPredicate p)
{
    for (; first != last; ++first) {
        if (p(*first)) return false;
    }
    return true;
}

[editar] 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 << "Among the numbers: ";
    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 << "All numbers are even\n";
    }
    if (std::none_of(v.cbegin(), v.cend(), std::bind(std::modulus<int>(), 
                                                     std::placeholders::_1, 2))) {
        std::cout << "None of them are odd\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 << "At least one number is divisible by 7\n";
    }
}

Salida:

Among the numbers: 2 4 6 8 10 12 14 16 18 20 
All numbers are even
None of them are odd
At least one number is divisible by 7