Namespaces
Variants

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

    From de.cppreference.net
    C++
    Experimental
    Ranges
    Algorithms library
    Non-modifying sequence operations
    all_of any_of none_of
    Modifying sequence operations
    Partitioning operations
    Sorting operations
    Binary search operations
    Set operations (on sorted ranges)
    Heap operations
    Minimum/maximum operations
    Permutations
    (Anmerkung: Der bereitgestellte HTML-Code enthält keinen übersetzbaren Text, da alle Tags leer sind. Die Struktur bleibt unverändert, wie angefordert.)
    template < InputIterator I, Sentinel < I > S, class Proj = ranges:: identity ,

    IndirectUnaryPredicate < projected < I, Proj >> Pred >

    bool all_of ( I first, S last, Pred pred, Proj proj = Proj { } ) ;
    		(1) (ranges TS)
    template < InputRange R, class Proj = ranges:: identity ,

    IndirectUnaryPredicate < projected < ranges:: iterator_t < R > , Proj >> Pred >

    bool all_of ( R && r, Pred pred, Proj proj = Proj { } ) ;
    		(2) (ranges TS)
    template < InputIterator I, Sentinel < I > S, class Proj = ranges:: identity ,

    IndirectUnaryPredicate < projected < I, Proj >> Pred >

    bool any_of ( I first, S last, Pred pred, Proj proj = Proj { } ) ;
    		(3) (ranges TS)
    template < InputRange R, class Proj = ranges:: identity ,

    IndirectUnaryPredicate < projected < ranges:: iterator_t < R > , Proj >> Pred >

    bool any_of ( R && r, Pred pred, Proj proj = Proj { } ) ;
    		(4) (ranges TS)
    template < InputIterator I, Sentinel < I > S, class Proj = identity,

    IndirectUnaryPredicate < projected < I, Proj >> Pred >

    bool none_of ( I first, S last, Pred pred, Proj proj = Proj { } ) ;
    		(5) (ranges TS)
    template < InputRange R, class Proj = ranges:: identity ,

    IndirectUnaryPredicate < projected < ranges:: iterator_t < R > , Proj >> Pred >

    bool none_of ( R && r, Pred pred, Proj proj = Proj { } ) ;
    		(6) (ranges TS)
    1) Prüft, ob das unäre Prädikat pred für alle Elemente im Bereich [ first , last ) true zurückgibt.
    3) Prüft, ob das unäre Prädikat pred für mindestens ein Element im Bereich [ first , last ) true zurückgibt.
    5) Prüft, ob das unäre Prädikat pred für keine Elemente im Bereich [ first , last ) true zurückgibt.
    2,4,6) Gleich wie (1,3,5) , verwendet jedoch r als Quellbereich, als ob ranges:: begin ( r ) als first und ranges:: end ( r ) als last verwendet würde.

    Ungeachtet der oben dargestellten Deklarationen sind die tatsächliche Anzahl und Reihenfolge der Template-Parameter für Algorithmusdeklarationen nicht spezifiziert. Daher ist ein Programm wahrscheinlich nicht portabel, wenn explizite Template-Argumente beim Aufruf eines Algorithmus verwendet werden.

    Inhalt

    Parameter

    first, last - der Bereich der zu untersuchenden Elemente
    r - der Bereich der zu untersuchenden Elemente
    pred - Prädikat, das auf die projizierten Elemente angewendet wird
    proj - Projektion, die auf die Elemente angewendet wird

    Rückgabewert

    1,2) true wenn pred für alle Elemente im Bereich true zurückgibt, false andernfalls. Gibt true zurück, wenn der Bereich leer ist.
    3,4) true falls pred für mindestens ein Element im Bereich true zurückgibt, false andernfalls. Gibt false zurück, falls der Bereich leer ist.
    5,6) true wenn pred für keine Elemente im Bereich true zurückgibt, false andernfalls. Gibt true zurück, wenn der Bereich leer ist.

    Komplexität

    1-6) Höchstens last - first Anwendungen des Prädikats und last - first Anwendungen der Projektion.

    Mögliche Implementierung

    **Anmerkung:** Der gesamte Code innerhalb der `
    `-Tags wurde gemäß den Anweisungen nicht übersetzt, da es sich um C++-Code handelt. Die HTML-Struktur und Attribute bleiben ebenfalls unverändert.
    Erste Version 
    template<InputIterator I, Sentinel<I> S, class Proj = ranges::identity,
         IndirectUnaryPredicate<projected<I, Proj>> Pred>
bool all_of(I first, S last, Pred pred, Proj proj = Proj{})
{
    return ranges::find_if_not(first, last, std::ref(pred), std::ref(proj)) == last;
}
template<InputRange R, class Proj = ranges::identity,
         IndirectUnaryPredicate<projected<ranges::iterator_t<R>, Proj>> Pred>
bool all_of(R&& r, Pred pred, Proj proj = Proj{})
{
    return ranges::all_of(ranges::begin(r), ranges::end(r),
                          std::ref(pred), std::ref(proj));
}
    Zweite Version 
    template<InputIterator I, Sentinel<I> S, class Proj = ranges::identity,
         IndirectUnaryPredicate<projected<I, Proj>> Pred>
bool any_of(I first, S last, Pred pred, Proj proj = Proj{})
{
    return ranges::find_if(first, last, std::ref(pred), std::ref(proj)) != last;
}
template<InputRange R, class Proj = ranges::identity,
         IndirectUnaryPredicate<projected<ranges::iterator_t<R>, Proj>> Pred>
bool any_of(R&& r, Pred pred, Proj proj = Proj{})
{
    return ranges::any_of(ranges::begin(r), ranges::end(r),
                          std::ref(pred), std::ref(proj));
}
    Dritte Version 
    template<InputIterator I, Sentinel<I> S, class Proj = identity,
         IndirectUnaryPredicate<projected<I, Proj>> Pred>
bool none_of(I first, S last, Pred pred, Proj proj = Proj{})
{
    return ranges::find_if(first, last, std::ref(pred), std::ref(proj)) == last;
}
template<InputRange R, class Proj = ranges::identity,
         IndirectUnaryPredicate<projected<ranges::iterator_t<R>, Proj>> Pred>
bool none_of(R&& r, Pred pred, Proj proj = Proj{})
{
    return ranges::none_of(ranges::begin(r), ranges::end(r),
                           std::ref(pred), std::ref(proj));
}

    Beispiel

    Diesen Code ausführen 
    #include <experimental/ranges/algorithm>
#include <experimental/ranges/iterator>
#include <functional>
#include <iostream>
#include <iterator>
#include <numeric>
#include <vector>
namespace ranges = std::experimental::ranges;
int main()
{
    std::vector<int> v(10, 2);
    std::partial_sum(v.cbegin(), v.cend(), v.begin());
    std::cout << "Unter den Zahlen: ";
    ranges::copy(v, ranges::ostream_iterator<int>(std::cout, " "));
    std::cout << '\n';
    if (ranges::all_of(v.cbegin(), v.cend(), [](int i) { return i % 2 == 0; }))
        std::cout << "Alle Zahlen sind gerade\n";
    if (ranges::none_of(v, std::bind(std::modulus<int>(), std::placeholders::_1, 2)))
        std::cout << "Keine davon ist ungerade\n";
    struct DivisibleBy
    {
        const int d;
        DivisibleBy(int n) : d(n) {}
        bool operator()(int n) const { return n % d == 0; }
    };
    if (ranges::any_of(v, DivisibleBy(7)))
        std::cout << "Mindestens eine Zahl ist durch 7 teilbar\n";
}

    Ausgabe: 

    Unter den Zahlen: 2 4 6 8 10 12 14 16 18 20 
Alle Zahlen sind gerade
Keine davon ist ungerade
Mindestens eine Zahl ist durch 7 teilbar

    Siehe auch

    (C++11)(C++11)(C++11)
    		 prüft, ob ein Prädikat true für alle, einige oder keines der Elemente in einem Bereich ist
    (Funktionsvorlage & Algorithmus-Funktionsobjekt)
    (C++20)(C++20)(C++20)