Namespaces
Variants

    std::is_sorted

    Von de.cppreference.net
     
    C++
     
    Algorithmenbibliothek
    Eingeschränkte Algorithmen und Algorithmen auf Bereichen (C++20)
    Eingeschränkte Algorithmen, z.B. ranges::copy, ranges::sort, ...
    Nicht modifizierende Sequenzoperationen    
    Batch-Operationen
    (C++17)
    Suchoperationen
    Modifizierende Sequenzoperationen
    Kopieroperationen
    (C++11)
    (C++11)
    (C++11)
    Tauschoperationen
    Transformationsoperationen
    Generierungsoperationen
    Entfernungsoperationen
    Reihenfolgeändernde Operationen
    (bis C++17)(C++11)
    (C++20)(C++20)
    Stichprobenoperationen
    (C++17)

    Sortier- und verwandte Operationen
    Partitionierungsoperationen
    (C++11)    
    (C++11)

    Sortieroperationen
    Binäre Suchoperationen
    (auf partitionierten Bereichen)
    Mengenoperationen (auf sortierten Bereichen)
    Mischoperationen (auf sortierten Bereichen)
    Heap-Operationen
    Minimum/Maximum-Operationen
    (C++11)
    (C++17)
    Lexikografische Vergleichsoperationen
    (C++20)
    Permutationsoperationen


     
    Definiert in Header <algorithm> 
    template< class ForwardIt >
bool is_sorted( ForwardIt first, ForwardIt last );
    		(1) (seit C++11)
    (constexpr seit C++20)    		 
    template< class ExecutionPolicy, class ForwardIt >
bool is_sorted( ExecutionPolicy&& policy,
                ForwardIt first, ForwardIt last );
    		(2) (seit C++17) 
    template< class ForwardIt, class Compare >
bool is_sorted( ForwardIt first, ForwardIt last, Compare comp );
    		(3) (seit C++11)
    (constexpr seit C++20)    		 
    template< class ExecutionPolicy, class ForwardIt, class Compare >
bool is_sorted( ExecutionPolicy&& policy,
                ForwardIt first, ForwardIt last, Compare comp );
    		(4) (seit C++17)

    Prüft, ob die Elemente im Bereich [first, last) in nicht absteigender Reihenfolge sortiert sind.

    1) Prüft, ob die Elemente sortiert bezüglich operator<(bis C++20)std::less{}(seit C++20) sortiert sind.
    3) Prüft, ob die Elemente bezüglich comp sortiert sind.
    2,4) Wie (1,3), jedoch gemäß policy ausgeführt.
    Diese Überladungen nehmen nur dann an der Überladungsauflösung teil, wenn der Wert des folgenden Ausdrucks true ist:

    std::is_execution_policy_v<std::decay_t<ExecutionPolicy>>

    		(bis C++20)

    std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>

    		(seit C++20)

    Parameter

    first, last - das Paar von Iteratoren, das den Bereich der zu untersuchenden Elemente definiert
    policy - die zu verwendende Ausführungsrichtlinie
    comp - Vergleichsfunktionsobjekt (ein Objekt, das die Anforderungen von Compare erfüllt), das ​true zurückgibt, wenn das erste Argument kleiner als das zweite ist (d.h. davor geordnet ist).

    Die Signatur der Vergleichsfunktion sollte der folgenden entsprechen:

    bool cmp(const Type1& a, const Type2& b);

    Während die Signatur kein const& benötigt, darf die Funktion die übergebenen Objekte nicht modifizieren und muss in der Lage sein, alle Werte des Typs (möglicherweise const) Type1 und Type2 unabhängig von der Wertkategorie zu akzeptieren (daher ist Type1& nicht erlaubt, ebenso wenig Type1, es sei denn, für Type1 ist eine Verschiebung äquivalent zu einer Kopie(seit C++11)).
    Die Typen Type1 und Type2 müssen so sein, dass ein Objekt des Typs ForwardIt dereferenziert und dann implizit in beide konvertiert werden kann. ​

    Typanforderungen
    -
    ForwardIt muss die Anforderungen von LegacyForwardIterator erfüllen.
    -
    Compare muss die Anforderungen von Compare erfüllen.

    Rückgabewert

    true true, wenn die Elemente im Bereich in nicht absteigender Reihenfolge sortiert sind, false false andernfalls.

    Komplexität

    Gegeben N als std::distance(first, last):

    1,2) O(N) Vergleiche unter Verwendung von operator<(bis C++20)std::less{}(seit C++20).
    3,4) O(N) Anwendungen des Vergleichs comp.

    Ausnahmen

    Die Überladungen mit einem Template-Parameter namens ExecutionPolicy melden Fehler wie folgt:

    • Wenn die Ausführung einer im Rahmen des Algorithmus aufgerufenen Funktion eine Ausnahme auslöst und ExecutionPolicy eine der Standardrichtlinien ist, wird std::terminate aufgerufen. Für jede andere ExecutionPolicy ist das Verhalten implementierungsdefiniert.
    • Wenn der Algorithmus keinen Speicher zuweisen kann, wird std::bad_alloc ausgelöst.

    Mögliche Implementierung

    Siehe auch die Implementierungen in libstdc++ und libc++.


    is_sorted (1) 
    template<class ForwardIt>
bool is_sorted(ForwardIt first, ForwardIt last)
{
    return std::is_sorted_until(first, last) == last;
}
    is_sorted (3) 
    template<class ForwardIt, class Compare>
bool is_sorted(ForwardIt first, ForwardIt last, Compare comp)
{
    return std::is_sorted_until(first, last, comp) == last;
}

    Anmerkungen

    std::is_sorted gibt true für leere Bereiche und Bereiche der Länge eins zurück.

    Beispiel

    Diesen Code ausführen
    #include <algorithm>
#include <cassert>
#include <functional>
#include <iterator>
#include <vector>

int main()
{
    std::vector<int> v;
    assert(std::is_sorted(v.cbegin(), v.cend()) && "an empty range is always sorted");
    v.push_back(42);
    assert(std::is_sorted(v.cbegin(), v.cend()) && "a range of size 1 is always sorted");
    
    int data[] = {3, 1, 4, 1, 5};
    assert(not std::is_sorted(std::begin(data), std::end(data)));
    
    std::sort(std::begin(data), std::end(data));
    assert(std::is_sorted(std::begin(data), std::end(data)));
    assert(not std::is_sorted(std::begin(data), std::end(data), std::greater<>{}));
}

    Siehe auch

    (C++11)
    		 findet den größten sortierten Unterbereich
    (Funktionsschablone & Algorithmus-Funktionsobjekt)
    (C++20)
    (C++20)
    		 prüft, ob ein Bereich sortiert ist
    (Algorithmus-Funktionsobjekt)