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

Definiert in Header `<algorithm>`
Aufrufsignatur
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)	(seit 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)	(seit 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)	(seit 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)	(seit 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)	(seit 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)	(seit 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)	(seit 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)	(seit 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)	(seit 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)	(seit 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)	(seit 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)	(seit C++26)

Zur Definition von /*execution-policy*/, siehe diese Seite; zur Definition von /*sized-random-access-range*/, siehe diese Seite.

1,2) Überprüft, ob das unäre Prädikat pred für mindestens ein Element (projiziert durch false) im Bereich proj oder [first, last) r zurückgibt.

3,4) Überprüft, ob das unäre Prädikat pred für mindestens ein Element (projiziert durch true) im Bereich proj oder [first, last) r zurückgibt.

5,6) Überprüft, ob das unäre Prädikat pred für kein Element (projiziert durch true) im Bereich proj oder [first, last) r zurückgibt.

7-12) Wie (1-6), aber ausgeführt gemäß policy.

Die auf dieser Seite beschriebenen funktionsähnlichen Entitäten sind Algorithmusfunktionsobjekte (informell als Niebloids bekannt), das heißt:

Explizite Vorlagenargumentlisten können beim Aufruf von keinem von ihnen angegeben werden.
Keines von ihnen ist für argumentabhängige Suche sichtbar.
Wenn eines von ihnen durch normale unqualifizierte Suche als Name links vom Funktionsaufrufoperator gefunden wird, wird argumentabhängige Suche unterdrückt.

Parameter

first, last	-	das Iterator-Sentinel-Paar, das den Bereich der zu untersuchenden Elemente definiert
r	-	der Bereich der zu untersuchenden Elemente
pred	-	das Prädikat, das auf die (projizierten) Elemente angewendet werden soll
proj	-	die auf die Elemente anzuwendende Projektion
policy	-	die zu verwendende Ausführungsrichtlinie

Rückgabewert

Bereich hat ein `true` Element	Ja		Nein
Bereich hat ein `false` Element	Ja	Nein	Ja	Nein^[1]
`all_of`	`false`	`true`	`false`	`true`
`any_of`	`true`	`true`	`false`	`false`
`none_of`	`false`	`false`	`true`	`true`

↑ Der Bereich ist in diesem Fall leer.

Komplexität

Höchstens range::distance(first, last) oder range::distance(r) Anwendungen von pred und der proj.

Ausnahmen

7-12) Während des Ausführungsprozesses:

Wenn die für die Parallelisierung erforderlichen temporären Speicherressourcen nicht verfügbar sind, wird std::bad_alloc ausgelöst.
Wenn beim Zugriff auf Objekte über ein Algorithmusargument eine nicht gefangene Ausnahme ausgelöst wird, wird das Verhalten durch die Ausführungsrichtlinie bestimmt (für Standardrichtlinien wird std::terminate aufgerufen).

Mögliche Implementierung

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;

Beispiel

Diesen Code ausführen

#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";
}

Ausgabe:

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

Siehe auch

all_ofany_ofnone_of

(C++11)(C++11)(C++11)

prüft, ob ein Prädikat true für alle, für mindestens eines oder für kein Element in einem Bereich gilt
(Funktionstemplate)

[1] Der Bereich ist in diesem Fall leer.

[1]

Compilerunterstützung
Freistehend und gehostet
Sprache
Standardbibliothek
Standardbibliotheks-Header
Benannte Anforderungen
Funktionsmerkmals-Makros (C++20)
Sprachunterstützungsbibliothek
Konzeptbibliothek (C++20)
Diagnosebibliothek
Speicherverwaltungsbibliothek
Metaprogrammierbibliothek (C++11)
Allgemeine Dienstprogrammbibliothek
Containerbibliothek
Iteratorenbibliothek
Bereichsbibliothek (C++20)
Algorithmusbibliothek
Zeichenkettenbibliothek
Textverarbeitungsbibliothek
Numerikbibliothek
Datums- und Zeitbibliothek
Eingabe-/Ausgabebibliothek
Dateisystembibliothek (C++17)
Nebenläufigkeitsunterstützungsbibliothek (C++11)
Ausführungssteuerungsbibliothek (C++26)
Technische Spezifikationen
Symbolverzeichnis
Externe Bibliotheken

de.cppreference.net

Namespaces

Variants