Namespaces
Variants

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

    ja.cppreference.net より
     
    C++
    コンパイラサポート
    フリースタンディングとホステッド
    言語
    標準ライブラリ
    標準ライブラリヘッダ
    名前付き要件
    機能テストマクロ (C++20)
    言語サポートライブラリ
    コンセプトライブラリ (C++20)
    診断ライブラリ
    メモリ管理ライブラリ
    メタプログラミングライブラリ (C++11)
    汎用ユーティリティライブラリ
    コンテナライブラリ
    イテレータライブラリ
    レンジライブラリ (C++20)
    アルゴリズムライブラリ
    文字列ライブラリ
    テキスト処理ライブラリ
    数値ライブラリ
    日時ライブラリ
    入出力ライブラリ
    ファイルシステムライブラリ (C++17)
    並行処理サポートライブラリ (C++11)
    実行制御ライブラリ (C++26)
    技術仕様
    シンボル索引
    外部ライブラリ
     
    アルゴリズムライブラリ
    制約付きアルゴリズムとレンジ上のアルゴリズム (C++20)
    制約付きアルゴリズム（例：ranges::copy, ranges::sort, ...）
    ソートと関連操作
    分割操作
    (C++11)    
    (C++11)

    ソート操作
    二分探索操作
    (分割されたレンジ上)
    集合操作（ソート済みレンジ上）
    マージ操作（ソート済みレンジ上）
    ヒープ操作
    最小値/最大値操作
    (C++11)
    (C++17)
    辞書式比較操作
    (C++20)
    順列操作


     
    制約付きアルゴリズム
    このメニュー内の全ての名前は名前空間 std::ranges
    非変更シーケンス操作
    変更シーケンス操作
    分割操作
    ソート操作
    二分探索操作（ソート済みレンジ上）
           
           
        
    集合操作（ソート済みレンジ上）
    ヒープ操作
    最小値/最大値操作
           
           
    順列操作
    畳み込み操作
    数値操作
    (C++23)            
    未初期化ストレージに対する操作
    戻り値の型
     
    ヘッダ <algorithm>
    呼び出しシグネチャ
    		 
    template< std::input_iterator I, std::sentinel_for<I> S,
          class Proj = std::identity,
          std::indirect_unary_predicate<std::projected<I, Proj>> Pred >
constexpr bool all_of( I first, S last, Pred pred, Proj proj = {} );
    		(1) (C++20以降) 
    template< ranges::input_range R, class Proj = std::identity,
          std::indirect_unary_predicate
              <std::projected<ranges::iterator_t<R>, Proj>> Pred >
constexpr bool all_of( R&& r, Pred pred, Proj proj = {} );
    		(2) (C++20以降) 
    template< std::input_iterator I, std::sentinel_for<I> S,
          class Proj = std::identity,
          std::indirect_unary_predicate<std::projected<I, Proj>> Pred >
constexpr bool any_of( I first, S last, Pred pred, Proj proj = {} );
    		(3) (C++20以降) 
    template< ranges::input_range R, class Proj = std::identity,
          std::indirect_unary_predicate
              <std::projected<ranges::iterator_t<R>, Proj>> Pred >
constexpr bool any_of( R&& r, Pred pred, Proj proj = {} );
    		(4) (C++20以降) 
    template< std::input_iterator I, std::sentinel_for<I> S,
          class Proj = std::identity,
          std::indirect_unary_predicate<std::projected<I, Proj>> Pred >
constexpr bool none_of( I first, S last, Pred pred, Proj proj = {} );
    		(5) (C++20以降) 
    template< ranges::input_range R, class Proj = std::identity,
          std::indirect_unary_predicate
              <std::projected<ranges::iterator_t<R>, Proj>> Pred >
constexpr bool none_of( R&& r, Pred pred, Proj proj = {} );
    		(6) (C++20以降) 
    template< /*execution-policy*/ Ep, std::random_access_iterator I,
          std::sized_sentinel_for<I> S, class Proj = std::identity,
          std::indirect_unary_predicate<std::projected<I, Proj>> Pred >
bool all_of( Ep&& policy, I first, S last, Pred pred, Proj proj = {} );
    		(7) (C++26以降) 
    template< /*execution-policy*/ Ep,
          /*sized-random-access-range*/ R, class Proj = std::identity,
          std::indirect_unary_predicate
              <std::projected<ranges::iterator_t<R>, Proj>> Pred >
bool all_of( Ep&& policy, R&& r, Pred pred, Proj proj = {} );
    		(8) (C++26以降) 
    template< /*execution-policy*/ Ep, std::random_access_iterator I,
          std::sized_sentinel_for<I> S, class Proj = std::identity,
          std::indirect_unary_predicate<std::projected<I, Proj>> Pred >
bool any_of( Ep&& policy, I first, S last, Pred pred, Proj proj = {} );
    		(9) (C++26以降) 
    template< /*execution-policy*/ Ep,
          /*sized-random-access-range*/ R, class Proj = std::identity,
          std::indirect_unary_predicate
              <std::projected<ranges::iterator_t<R>, Proj>> Pred >
bool any_of( Ep&& policy, R&& r, Pred pred, Proj proj = {} );
    		(10) (C++26以降) 
    template< /*execution-policy*/ Ep, std::random_access_iterator I,
          std::sized_sentinel_for<I> S, class Proj = std::identity,
          std::indirect_unary_predicate<std::projected<I, Proj>> Pred >
bool none_of( Ep&& policy, I first, S last, Pred pred, Proj proj = {} );
    		(11) (C++26以降) 
    template< /*execution-policy*/ Ep,
          /*sized-random-access-range*/ R, class Proj = std::identity,
          std::indirect_unary_predicate
              <std::projected<ranges::iterator_t<R>, Proj>> Pred >
bool none_of( Ep&& policy, R&& r, Pred pred, Proj proj = {} );
    		(12) (C++26以降)

    の定義については、/*execution-policy*/を、このページを参照してください。また、/*sized-random-access-range*/の定義については、このページを参照してください。

    1,2) 単項述語 pred が false を少なくとも1つの要素に対して返すかどうかをチェックする（射影 proj を使用）をレンジ [first, last) または r に対して行う。
    3,4) 単項述語 pred が true を少なくとも1つの要素に対して返すかどうかをチェックする（射影 proj を使用）をレンジ [first, last) または r に対して行う。
    5,6) 単項述語 pred が true をどの要素に対しても返さないかどうかをチェックする（射影 proj を使用）をレンジ [first, last) または r に対して行う。
    7-12) (1-6) と同じだが、policyに従って実行される。

    このページで説明されている関数状のエンティティはアルゴリズム関数オブジェクト（非公式にニーブロイドと呼ばれる）です。すなわち：

    • それらのいずれかを呼び出す際に、明示的なテンプレート実引数リストを指定することはできません。
    • それらは引数依存の名前探索に対して可視ではありません。
    • それらのいずれかが、関数呼び出し演算子の左側の名前として通常の非修飾名前探索によって発見された場合、引数依存の名前探索は抑制されます。

    パラメータ

    first, last - イテレータ-番兵ペアが定義する範囲の検査する要素
    r - 検査する要素の範囲
    pred - （射影された）要素に適用する述語
    proj - 要素に適用する射影
    policy - 実行ポリシー を使用する

    戻り値

    範囲にはいくつかのtrue要素がある はい いいえ
     範囲にはいくつかのfalse要素がある  はい いいえ はい     いいえ[1]
    all_of false true false true
    any_of true true   false     false  
    none_of   false     false   true true
    1. ↑ この場合、範囲は空です。

    計算量

    最大でもrange::distance(first, last)またはrange::distance(r)回のpredおよびprojの適用。

    例外

    7-12)実行プロセス中:
    • 並列化に必要な一時メモリリソースが利用できない場合、std::bad_allocがスローされます。
    • アルゴリズムの引数を介してオブジェクトにアクセス中にキャッチされない例外がスローされた場合、動作は実行ポリシーによって決定されます（標準ポリシーの場合はstd::terminateが呼び出されます）。

    実装例

    all_of (1,2) 
    struct all_of_fn
{
    template<std::input_iterator I, std::sentinel_for<I> S, class Proj = std::identity,
             std::indirect_unary_predicate<std::projected<I, Proj>> Pred>
    constexpr bool operator()(I first, S last, Pred pred, Proj proj = {}) const
    {
        return ranges::find_if_not(first, last, std::ref(pred), std::ref(proj)) == last;
    }
    
    template<ranges::input_range R, class Proj = std::identity,
             std::indirect_unary_predicate
                 <std::projected<ranges::iterator_t<R>, Proj>> Pred>
    constexpr bool operator()(R&& r, Pred pred, Proj proj = {}) const
    {
        return operator()(ranges::begin(r), ranges::end(r),
                          std::ref(pred), std::ref(proj));
    }
    
    template<ranges::forward_range R, class Proj = std::identity,
             std::indirect_unary_predicate
                 <std::projected<ranges::iterator_t<R>, Proj>> Pred>
    constexpr bool operator()(R&& r, Pred pred, Proj proj = {}) const
    {
        return operator()(ranges::begin(r),
                          ranges::next(ranges::begin(r), ranges::end(r)),
                          std::ref(pred), std::ref(proj));
    }
};

inline constexpr all_of_fn all_of;
    any_of (3,4) 
    struct any_of_fn
{
    template<std::input_iterator I, std::sentinel_for<I> S, class Proj = std::identity,
             std::indirect_unary_predicate<std::projected<I, Proj>> Pred>
    constexpr bool operator()(I first, S last, Pred pred, Proj proj = {}) const
    {
        return ranges::find_if(first, last, std::ref(pred), std::ref(proj)) != last;
    }
    
    template<ranges::input_range R, class Proj = std::identity,
             std::indirect_unary_predicate
                 <std::projected<ranges::iterator_t<R>, Proj>> Pred>
    constexpr bool operator()(R&& r, Pred pred, Proj proj = {}) const
    {
        return operator()(ranges::begin(r), ranges::end(r),
                          std::ref(pred), std::ref(proj));
    }
    
    template<ranges::forward_range R, class Proj = std::identity,
             std::indirect_unary_predicate
                 <std::projected<ranges::iterator_t<R>, Proj>> Pred>
    constexpr bool operator()(R&& r, Pred pred, Proj proj = {}) const
    {
        return operator()(ranges::begin(r),
                          ranges::next(ranges::begin(r), ranges::end(r)),
                          std::ref(pred), std::ref(proj));
    }
};

inline constexpr any_of_fn any_of;
    none_of (5,6) 
    struct none_of_fn
{
    template<std::input_iterator I, std::sentinel_for<I> S, class Proj = std::identity,
             std::indirect_unary_predicate<std::projected<I, Proj>> Pred>
    constexpr bool operator()(I first, S last, Pred pred, Proj proj = {}) const
    {
        return ranges::find_if(first, last, std::ref(pred), std::ref(proj)) == last;
    }
    
    template<ranges::input_range R, class Proj = std::identity,
             std::indirect_unary_predicate
                 <std::projected<ranges::iterator_t<R>, Proj>> Pred>
    constexpr bool operator()(R&& r, Pred pred, Proj proj = {}) const
    {
        return operator()(ranges::begin(r), ranges::end(r),
                          std::ref(pred), std::ref(proj));
    }
    
    template<ranges::forward_range R, class Proj = std::identity,
             std::indirect_unary_predicate
                 <std::projected<ranges::iterator_t<R>, Proj>> Pred>
    constexpr bool operator()(R&& r, Pred pred, Proj proj = {}) const
    {
        return operator()(ranges::begin(r),
                          ranges::next(ranges::begin(r), ranges::end(r)),
                          std::ref(pred), std::ref(proj));
    }
};

inline constexpr none_of_fn none_of;

    例

    このコードを実行 
    #include <algorithm>
#include <functional>
#include <iostream>
#include <iterator>
#include <numeric>
#include <vector>
namespace ranges = std::ranges;
constexpr bool some_of(auto&& r, auto&& pred) // some but not all
{
    return not (ranges::all_of(r, pred) or ranges::none_of(r, pred));
}
constexpr auto w = {1, 2, 3};
static_assert(!some_of(w, [](int x) { return x < 1; }));
static_assert( some_of(w, [](int x) { return x < 2; }));
static_assert(!some_of(w, [](int x) { return x < 4; }));
int main()
{
    std::vector<int> v(10, 2);
    std::partial_sum(v.cbegin(), v.cend(), v.begin());
    std::cout << "Among the numbers: ";
    ranges::copy(v, std::ostream_iterator<int>(std::cout, " "));
    std::cout << '\n';
    if (ranges::all_of(v.cbegin(), v.cend(), [](int i) { return i % 2 == 0; }))
        std::cout << "All numbers are even\n";
    if (ranges::none_of(v, std::bind(std::modulus<int>(), std::placeholders::_1, 2)))
        std::cout << "None of them are odd\n";
    auto DivisibleBy = [](int d)
    {
        return [d](int m) { return m % d == 0; };
    };
    if (ranges::any_of(v, DivisibleBy(7)))
        std::cout << "At least one number is divisible by 7\n";
}

    出力: 

    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

    関連項目

    (C++11) (C++11) (C++11)
    		述語が範囲内のすべての要素、いずれかの要素、またはどの要素に対しても true であるかどうかをチェックする
    (関数テンプレート)