std::list<T,Allocator>::sort

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Container-Bibliothek

Sequenz

array (C++11)

vector

vector<bool>

inplace_vector (C++26)

hive (C++26)

deque

forward_list (C++11)

list

Assoziativ

setzt

multiset

map

multimap

Ungeordnete assoziative

unordered_set (C++11)

unordered_multiset (C++11)

unordered_map (C++11)

unordered_multimap (C++11)

Adapter

stack

queue

priority_queue

flat_set (C++23)

flat_multiset (C++23)

flat_map (C++23)

flat_multimap (C++23)

Ansichten

span (C++20)

mdspan (C++23)

Tabellen

Iterator-Invalidierung

Mitgliedsfunktionstabelle

Nicht-Mitgliedsfunktionstabelle

 

std::list

Memberfunktionen
list::list list::~list list::operator= list::assign list::assign_range (C++23)   list::get_allocator Elementzugriff list::front list::back Iteratoren list::beginlist::cbegin (C++11) list::endlist::cend (C++11) list::rbeginlist::crbegin (C++11) list::rendlist::crend (C++11) Kapazität list::size list::empty list::max_size	Modifizierer list::clear list::insert list::insert_range (C++23) list::emplace (C++11) list::erase list::push_front list::emplace_front (C++11) list::prepend_range (C++23) list::pop_front list::push_back list::emplace_back (C++11) list::append_range (C++23) list::pop_back list::resize list::swap Operationen list::merge list::splice list::removelist::remove_if list::reverse list::unique list::sort
Nicht-Member-Funktionen
operator==operator<=> (C++20) swap(std::list) erase(std::list)erase_if(std::list) (C++20)(C++20)	operator!=operator<operator>operator<=operator>= (bis C++20)(bis C++20)(bis C++20)(bis C++20)(bis C++20)
Deduktionshilfen(C++17)

 

void sort();	(1)
template< class Compare > void sort( Compare comp );	(2)

Sortiert die Elemente und erhält die Reihenfolge von äquivalenten Elementen. Keine Referenzen oder Iteratoren werden ungültig.

1) Elemente werden mittels operator< verglichen.

2) Elemente werden mit comp verglichen.

Wenn eine Ausnahme ausgelöst wird, ist die Reihenfolge der Elemente in *this undefiniert.

Parameter

comp	-	Vergleichsfunktions-Objekt (d.h. ein Objekt, das die Anforderungen an Compare erfüllt), das ​true zurückgibt, wenn das erste Argument *weniger* (d.h. *vorher*) als das zweite geordnet ist. Die Signatur der Vergleichsfunktion sollte äquivalent zu Folgendem sein bool cmp(const Type1& a, const Type2& b); Obwohl die Signatur nicht unbedingt const& haben muss, darf die Funktion die übergebenen Objekte nicht verändern und muss in der Lage sein, alle Werte vom Typ (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 ein Move äquivalent zu einem Kopieren(since C++11)). Die Typen Type1 und Type2 müssen so beschaffen sein, dass ein Objekt vom Typ list<T,Allocator>::const_iterator dereferenziert und dann implizit in beide konvertiert werden kann. ​
Typanforderungen
- Compare muss die Anforderungen an Compare erfüllen.

Rückgabewert

(keine)

Komplexität

Gegeben sei \(\scriptsize N\)N als size()

1) Ungefähr \(\scriptsize N \cdot log(N)\)N·log(N) Vergleiche mit operator<.

2) Ungefähr \(\scriptsize N \cdot log(N)\)N·log(N) Anwendungen der Vergleichsfunktion comp.

Anmerkungen

std::sort benötigt zufällige Zugriffsiteratoren und kann daher nicht mit list verwendet werden. Diese Funktion unterscheidet sich auch von std::sort dadurch, dass sie nicht erfordert, dass der Elementtyp der list vertauschbar ist, die Werte aller Iteratoren beibehält und eine stabile Sortierung durchführt.

Beispiel

Führen Sie diesen Code aus

#include <functional>
#include <iostream>
#include <list>
 
std::ostream& operator<<(std::ostream& ostr, const std::list<int>& list)
{
    for (const int i : list)
        ostr << ' ' << i;
    return ostr;
}
 
int main()
{
    std::list<int> list{8, 7, 5, 9, 0, 1, 3, 2, 6, 4};
    std::cout << "initially: " << list << '\n';
 
    list.sort();
    std::cout << "ascending: " << list << '\n';
 
    list.sort(std::greater<int>());
    std::cout << "descending:" << list << '\n';
}

Ausgabe

initially:  8 7 5 9 0 1 3 2 6 4
ascending:  0 1 2 3 4 5 6 7 8 9
descending: 9 8 7 6 5 4 3 2 1 0

Defect reports

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 1207	C++98	war unklar, ob Iteratoren und/oder Referenzen ungültig werden	gültig bleiben

Siehe auch

reverse

kehrt die Reihenfolge der Elemente um (public member function)