C++11

// <algorithm> 
template <class InputIterator,
    class UnaryPredicate>
        bool all_of (InputIterator first,
​            InputIterator last, UnaryPredicate pred);

检测在给定范围中是否所有元素都满足给定的条件。

该函数等价于:

template<class _InIt,
    class _Pr> inline
    bool _All_of(_InIt _First, _InIt _Last, _Pr _Pred)
    {	// test if all elements satisfy _Pred
        for (; _First != _Last; ++_First)
            if (!_Pred(*_First))
                return (false);
        return (true);
    }
  • firstlast

    分别指向一个序列中初始及末尾位置的输入迭代器。这个范围即 [first,last) ,包括 first 到 last 间的所有元素,包括 first 指向的元素,但不包括 last 指向的元素。

    pred

    一元谓词(Unary)函数,以范围中的一个元素为参数,然后返回一个可转换成 bool 类型的值。

    其返回值表明指定元素是否满足当前函数所检测的条件。

    该函数不能修改其参数。

    可以是函数指针(Function pointer)类型或函数对象(Function object)类型。

    返回

    当范围中的所有元素传入 pred 后都返回 ture,则 all_of 返回 ture

    当范围为空,返回 true

    否则,返回 false

  • 例 1

    #include <iostream>
    #include <vector>
    #include <algorithm>
    
    namespace ClassFoo{
        // 判断字符是否为 'C'
        bool HasAnC(char Char) {
            return (Char == 'C');
        }
        void AllOf_1() {
            std::vector<char> MyVector;
            MyVector.push_back('C');
            MyVector.push_back('l');
            MyVector.push_back('a');
            MyVector.push_back('s');
            MyVector.push_back('s');
            MyVector.push_back('f');
            MyVector.push_back('o');
            MyVector.push_back('o');
            MyVector.push_back('.');
            MyVector.push_back('c');
            MyVector.push_back('o');
            MyVector.push_back('m');
    
            // 检测 MyVector 中的所有元素
            bool bAnyIsC = std::all_of(MyVector.begin(), MyVector.end(), HasAnC);
            std::cout << "是否全是 'C':" << std::boolalpha << bAnyIsC << std::endl;
    
            std::vector<char>::iterator it = MyVector.begin();
            ++it;
            // 检测 MyVector 中的第一个元素
            bAnyIsC = std::all_of(MyVector.begin(), it, HasAnC);
            std::cout << "是否全是 'C':" << std::boolalpha << bAnyIsC << std::endl;
        }
    }
    
    int main()
    {
        ClassFoo::AllOf_1();
        std::cin.get();
        return 0;
    }

    输出:

    是否全是 'C':false
    是否全是 'C':true​

    例 2

    #include <iostream>
    #include <vector>
    #include <algorithm>
    
    namespace ClassFoo{
        void AllOf_2() {
            std::vector<int> foo = { 12, 9, 'c', 123123, 1, 1, 44, 11 };
    
            if (std::all_of(foo.begin(), foo.end(), [](int n){return n > 0; }))
                std::cout << "所有元素都大于 0.\n";
        }
    }
    
    int main()
    {
        ClassFoo::AllOf_2();
        std::cin.get();
        return 0;
    }

    所有元素都大于 0.

    例 3

    使用 lambda 表达式

    // 返回是否所有数字都是偶数的
    std::all_of(v.cbegin(), v.cend(), [](int i){ return i % 2 == 0; })

    例 4

    使用 std::bind 生成函数对象

    // 这是一个使用 std::bind 传递函数对象的例子
    bool fun(int value, int min, int max)
    {
       return value > min && value < max;
    }
    std::all_of(v.begin(),v.end(),std::bind(fun, std::placeholders::_1, 1, 5));

    例 5

    使用 struct 的函数操作符成员函数生成函数对象

    // 在当前范围中,是否所有元素都能被7整除
    struct DivisibleBy
    {
        const int d;
        DivisibleBy(int n) : d(n) {}
        bool operator()(int n) const { return n % d == 0; }
    };
     
    if (std::all_of(v.cbegin(), v.cend(), DivisibleBy(7))) {
        std::cout << "所有元素都能被 7 整除\n";
    }
  • 复杂度

    最多执行 last - firstpred,一旦发现未匹配就返回。

    数据争用相关

    访问在范围 [first,last) 中的部份(或所有)元素,但最多访问一次。

    异常安全性相关

    如果 pred 或操作某个迭代器抛异常,该函数才会抛异常。

    注意 无效参数将导致未定义行为(Undefined behavior)