C++11

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

检测在给定范围中是否存在元素满足给定条件。

该函数等价于:

class _Pr> inline
    bool _Any_of(_InIt _First, _InIt _Last, _Pr _Pred)
    {	// test if any element satisfies _Pred
    for (; _First != _Last; ++_First)
        if (_Pred(*_First))
            return (true);
    return (false);
    }
  • firstlast

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

    pred

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

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

    该函数不能修改其参数。

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

    返回

    当范围中存在某个元素传入 pred 后返回 ture,则 any_of 返回 ture,否则返回 false

    当范围为空,返回 false

  • 例 1

    #include <iostream>
    #include <vector>
    #include <algorithm>
    
    namespace ClassFoo{
        // 判断字符是否为 '.'
        bool HasAnPoint(char Char) {
            return (Char == '.');
        }
        void AnyOf_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 bExistPoint = std::any_of(MyVector.begin(), MyVector.end(), HasAnPoint);
            std::cout << "是否存在 '.':" << std::boolalpha << bExistPoint << std::endl;
    
            std::vector<char>::iterator it = MyVector.begin();
            ++it;
            // 检测 MyVector 中的第一个元素
            bExistPoint = std::any_of(MyVector.begin(), it, HasAnPoint);
            std::cout << "是否存在 '.':" << std::boolalpha << bExistPoint << std::endl;
        }
    }
    
    int main()
    {
        ClassFoo::AnyOf_1();
        std::cin.get();
        return 0;
    }

    是否存在 '.':true
    是否存在 '.':false

    例 2

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

    存在元素大于 100.

    例 3

    使用 lambda 表达式

    // 返回是否存在偶数
    std::any_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::any_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::any_of(v.cbegin(), v.cend(), DivisibleBy(7))) {
        std::cout << "At least one number is divisible by 7\n";
    }
  • 复杂度

    最多执行 last first 次 pred,一旦发现匹配就返回。

    数据争用相关

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

    异常安全性相关

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

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