Esiste un algoritmo STL/boost per verificare che tutti gli elementi in un contenitore corrispondano a un valore?

Question

Esiste un algoritmo STL/boost che verificherà se tutti gli elementi tra due iteratori corrispondono a un determinato valore? O in alternativa che un predicato restituisce true per tutti loro?

vale a dire una cosa del genere

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

Se si può negare il predicato è possibile utilizzare std :: trovare/std :: find_if e vedere se restituisce l'elemento terminale della sequenza. In caso contrario, restituisce quello che corrisponde.

È possibile adattare una funzione con std :: not1 o std :: not_equal_to così facendo combinato con std :: find_if si può effettivamente farlo usando STL senza scrivere un ciclo.

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

Si potrebbe usare std: trovare ord std :: find_if per fare questo.

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

È possibile utilizzare std::equal con il predicato. Qualcosa di simile:

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 introduce std::all_of.

Answer 5

Spesso si può semplicemente contare:

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); 
} 

inefficiente quando l'iteratore non è casuale, o quando restituisce false. Non funziona per gli iteratori di input.