Namespaces
Variants

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

    cppreference.net에서 제공
     
    C++
     
    알고리즘 라이브러리
    제약된 알고리즘 및 범위에 대한 알고리즘 (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를 적어도 하나의 요소에 대해 반환하는지 (proj에 의해 투영된) 범위 [first, last) 또는 r 내에서 확인합니다.
    3,4) 단항 조건자 pred가 true를 적어도 하나의 요소에 대해 반환하는지 (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) // 일부만 해당 (전체는 아님)
{
    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 << "숫자들: ";
    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 << "모든 숫자가 짝수입니다\n";
    if (ranges::none_of(v, std::bind(std::modulus<int>(), std::placeholders::_1, 2)))
        std::cout << "어떤 숫자도 홀수가 아닙니다\n";
    auto DivisibleBy = [](int d)
    {
        return [d](int m) { return m % d == 0; };
    };
    if (ranges::any_of(v, DivisibleBy(7)))
        std::cout << "적어도 하나의 숫자가 7로 나누어집니다\n";
}

    출력: 

    숫자들: 2 4 6 8 10 12 14 16 18 20
모든 숫자가 짝수입니다
어떤 숫자도 홀수가 아닙니다
적어도 하나의 숫자가 7로 나누어집니다

    참고 항목

    (C++11) (C++11) (C++11)
    		범위 내의 모든 요소에 대해 조건자가 true 인지, 일부 요소에 대해 true인지, 또는 어떤 요소에도 true가 아닌지 검사합니다
    (함수 템플릿)