Namespaces
Variants

    std::stable_partition

    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
    Erzeugungsoperationen
    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 BidirIt, class UnaryPred >
BidirIt stable_partition( BidirIt first, BidirIt last, UnaryPred p );
    		(1) (constexpr seit C++26) 
    template< class ExecutionPolicy, class BidirIt, class UnaryPred >
BidirIt stable_partition( ExecutionPolicy&& policy,
                          BidirIt first, BidirIt last, UnaryPred p );
    		(2) (seit C++17)
    1) Ordnet die Elemente im Bereich [first, last) so an, dass alle Elemente, für die das Prädikat p true zurückgibt, den Elementen vorausgehen, für die das Prädikat p false zurückgibt. Die relative Reihenfolge der Elemente bleibt erhalten.
    2) Gleich wie (1), aber gemäß policy ausgeführt.
    Diese Überladung nimmt 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)

    Wenn eine der folgenden Bedingungen erfüllt ist, ist das Verhalten undefiniert:

    (bis C++11)
    (seit C++11)

    Parameter

    first, last - das Paar von Iteratoren, das den Bereich der umzuordnenden Elemente definiert
    policy - die zu verwendende Ausführungsrichtlinie
    p - unäres Prädikat, das ​ true zurückgibt, wenn das Element vor anderen Elementen angeordnet werden soll.

    Der Ausdruck p ( v ) muss für jedes Argument v vom Typ (möglicherweise const) VT in bool konvertierbar sein, wobei VT der Werttyp von BidirIt ist, unabhängig von der Wertkategorie , und darf v nicht modifizieren. Daher ist ein Parametertyp VT & nicht zulässig , ebenso wenig wie VT , es sei denn, für VT ist eine Verschiebung äquivalent zu einer Kopie (seit C++11) . ​

    Typanforderungen
    -
    BidirIt muss die Anforderungen von LegacyBidirectionalIterator erfüllen.
    -
    UnaryPred muss die Anforderungen von Predicate erfüllen.

    Rückgabewert

    Iterator zum ersten Element der zweiten Gruppe.

    Komplexität

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

    1) Genau N Anwendungen von p .
    O(N) Vertauschungen, wenn genügend zusätzlicher Speicher vorhanden ist, andernfalls höchstens N⋅log 2 (N) Vertauschungen.
    2) O(N) Anwendungen von p .
    N⋅log(N) Vertauschungen.

    Exceptions

    Die Überladung mit einem Template-Parameter namens ExecutionPolicy meldet Fehler wie folgt:

    • Wenn die Ausführung einer als Teil des Algorithmus aufgerufenen Funktion eine Exception wirft und ExecutionPolicy einer der Standard-Policies ist, wird std::terminate aufgerufen. Für jede andere ExecutionPolicy ist das Verhalten implementierungsdefiniert.
    • Wenn der Algorithmus keinen Speicher allozieren kann, wird std::bad_alloc geworfen.

    Hinweise

    Diese Funktion versucht, einen temporären Puffer zu allozieren. Falls die Allokation fehlschlägt, wird der weniger effiziente Algorithmus gewählt.

    Implementierungen in libc++ und libstdc++ akzeptieren ebenfalls durch LegacyForwardIterator s definierte Bereiche als Erweiterung.

    Feature-Test Makro Wert Std Feature
    __cpp_lib_constexpr_algorithms 202306L (C++26) constexpr stabile Sortierung ( 1 )

    Beispiel

    Diesen Code ausführen 
    #include <algorithm>
#include <iostream>
#include <vector>
int main()
{
    std::vector<int> v{0, 0, 3, -1, 2, 4, 5, 0, 7};
    std::stable_partition(v.begin(), v.end(), [](int n) { return n > 0; });
    for (int n : v)
        std::cout << n << ' ';
    std::cout << '\n';
}

    Ausgabe: 

    3 2 4 5 7 0 0 -1 0

    Fehlerberichte

    Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

    DR Angewendet auf Verhalten wie veröffentlicht Korrigiertes Verhalten
    LWG 2150 C++98 std::stable_partition musste nur ein
    Element, das p erfüllt, vor einem Element platzieren, das p nicht erfüllt     		Anforderung
    korrigiert

    Siehe auch

    		 teilt einen Bereich von Elementen in zwei Gruppen auf
    (Funktionsschablone & Algorithmus-Funktionsobjekt)
    (C++20)
    (C++20)
    		 teilt Elemente in zwei Gruppen auf, während die relative Reihenfolge innerhalb jeder Gruppe erhalten bleibt
    (Algorithmus-Funktionsobjekt)