¿Hay un algoritmo STL/boost para verificar que todos los elementos en un contenedor coinciden con un valor?

Question

¿Hay un algoritmo STL/boost que verificará si todos los elementos entre dos iteradores coinciden con un valor dado? ¿O alternativamente que un predicado devuelve true para todos ellos?

es decir, algo así como

template<class InputIterator, class T> 
InputIterator all_match (InputIterator first, InputIterator last, const T& value) 
{ 
    bool allMatch = true; 
    while(allMatch && first!=last) 
     allMatch = (value == *first++); 
    return allMatch; 
} 

O

template <class InputIterator, class Predicate> 
bool all_true (InputIterator first, InputIterator last, Predicate pred) 
{ 
    bool allTrue = true; 
    while (allTrue && first != last) 
     allTrue = pred(*first++); 
    return allTrue; 
} 

Answer 1

Si se puede negar el predicado puede utilizar std :: find/std :: find_if y ver si se devuelve el elemento final de la secuencia. Si no, entonces devuelve el que no coincide.

Puede adaptar una función con std :: not1 o std :: not_equal_to haciendo esto combinado con std :: find_if puede hacerlo usando STL sin escribir un bucle.

bool allMatch = seq.end() == std::find_if(seq.begin(), seq.end(), 
    std::not_equal_to(val)); 
bool allPass = seq.end() == std::find_if(seq.begin(), seq.end(), 
    std::not1(pred)); 

Answer 2

Usted podría utilizar std: encontrar ord std :: find_if para hacer esto.

template <class T> 
struct pred { 
    T t_; 

    pred(const T& value) : t_(value) {} 

    bool operator()(const T &t) 
    { 
     return t != t_; 
    } 
}; 

if (e.cend() == std::find_if(c.cbegin(), c.cend(), pred<T>(value))) 
    print("all match value"); 

Answer 3

Puede utilizar std::equal con el predicado. Algo como:

using namespace std; 
using namespace boost::lambda; 

int main() 
{ 
    vector<int> a; 
    a.push_back(1); 
    a.push_back(1); 
    a.push_back(2); 
    a.push_back(2); 
    a.push_back(3); 
    bool allMatch = equal(a.begin(), a.begin() + 2, a.begin(), _1 == 1); 
    return 0; 
} 

Answer 4

C++ 0x presenta std::all_of.

Answer 5

A menudo se puede contar sólo ellos:

template<class FwdIterator, class T> 
InputIterator all_match (FwdIterator first, FwdIterator last, const T& value) 
{ 
    return std::count(first, last, value) == std::distance(first, last); 
} 

ineficiente cuando el iterador no es al azar, o cuando se devuelve falso. No funciona para los iteradores de entrada.