Namespaces
Variants

Containers library

From cppreference.net

Die Containers-Bibliothek ist eine generische Sammlung von Klassentemplates und Algorithmen, die es Programmierern ermöglicht, gängige Datenstrukturen wie Warteschlangen, Listen und Stapel einfach zu implementieren. Es gibt zwei (until C++11) drei (since C++11) Klassen von Containern:

  • Sequenzcontainer,
  • Assoziative Container,
  • Ungeordnete assoziative Container,
(seit C++11)

von denen jede entwickelt wurde, um einen unterschiedlichen Satz von Operationen zu unterstützen.

Der Container verwaltet den Speicherplatz, der für seine Elemente alloziert ist, und stellt Member-Funktionen bereit, um darauf zuzugreifen, entweder direkt oder durch Iteratoren (Objekte mit Eigenschaften ähnlich Zeigern).

Die meisten Container haben mindestens mehrere Memberfunktionen gemeinsam und teilen Funktionalitäten. Welcher Container für eine bestimmte Anwendung am besten geeignet ist, hängt nicht nur von der angebotenen Funktionalität ab, sondern auch von seiner Effizienz für verschiedene Arbeitslasten.

Inhaltsverzeichnis

Sequenzcontainer

Sequenzcontainer implementieren Datenstrukturen, die sequenziell abgerufen werden können.

(C++11)
Festgroße Inplace-Contiguous-Array
(Klassentemplate)
Veränderbare Contiguous-Array
(Klassentemplate)
Veränderbare, feste Kapazität, Inplace-Contiguous-Array
(Klassentemplate)
(C++26)
Sammlung, die Speicher gelöschter Elemente wiederverwendet
(Klassentemplate)
Doppelendige Warteschlange
(Klassentemplate)
Einfach verknüpfte Liste
(Klassentemplate)
Doppelt verknüpfte Liste
(Klassentemplate)

Assoziative Container

Assoziative Container implementieren sortierte Datenstrukturen, die schnell durchsucht werden können ( O(log n) Komplexität).

Sammlung eindeutiger Schlüssel, sortiert nach Schlüsseln
(Klassen-Template)
Sammlung von Schlüssel-Wert-Paaren, sortiert nach Schlüsseln, Schlüssel sind eindeutig
(Klassen-Template)
Sammlung von Schlüsseln, sortiert nach Schlüsseln
(Klassen-Template)
Sammlung von Schlüssel-Wert-Paaren, sortiert nach Schlüsseln
(Klassen-Template)

Ungeordnete assoziative Container (since C++11)

Ungeordnete assoziative Container implementieren ungeordnete (gehashte) Datenstrukturen, die schnell durchsucht werden können ( O(1) durchschnittlich, O(n) Worst-Case-Komplexität).

Sammlung eindeutiger Schlüssel, gehasht nach Schlüsseln
(Klassentemplate)
Sammlung von Schlüssel-Wert-Paaren, gehasht nach Schlüsseln, Schlüssel sind eindeutig
(Klassentemplate)
Sammlung von Schlüsseln, gehasht nach Schlüsseln
(Klassentemplate)
Sammlung von Schlüssel-Wert-Paaren, gehasht nach Schlüsseln
(Klassentemplate)

Container-Adapter

Container-Adaptoren bieten eine andere Schnittstelle für sequentielle Container.

passt einen Container an, um einen Stack (LIFO-Datenstruktur) bereitzustellen
(Klassentemplate)
passt einen Container an, um eine Warteschlange (FIFO-Datenstruktur) bereitzustellen
(Klassentemplate)
passt einen Container an, um eine Prioritätswarteschlange bereitzustellen
(Klassentemplate)
(C++23)
passt einen Container an, um eine Sammlung eindeutiger Schlüssel, sortiert nach Schlüsseln, bereitzustellen
(Klassentemplate)
(C++23)
passt zwei Container an, um eine Sammlung von Schlüssel-Wert-Paaren, sortiert nach eindeutigen Schlüsseln, bereitzustellen
(Klassentemplate)
passt einen Container an, um eine Sammlung von Schlüsseln, sortiert nach Schlüsseln, bereitzustellen
(Klassentemplate)
passt zwei Container an, um eine Sammlung von Schlüssel-Wert-Paaren, sortiert nach Schlüsseln, bereitzustellen
(Klassentemplate)

Views (seit C++20)

Views bieten flexible Möglichkeiten zur Interaktion mit ein- oder mehrdimensionalen Ansichten über ein nicht-besitzendes Array von Elementen.

(C++20)
eine nicht-besitzende Ansicht über eine zusammenhängende Objektsequenz
(Klassentemplate)
(C++23)
eine mehrdimensionale nicht-besitzende Array-Ansicht
(Klassentemplate)

Iterator-Invalidierung

Schreibgeschützte Methoden machen Iteratoren oder Referenzen niemals ungültig . Methoden, die den Inhalt eines Containers verändern, können Iteratoren und/oder Referenzen ungültig machen, wie in dieser Tabelle zusammengefasst.

Kategorie Container Nach Einfügung sind... Nach Löschung sind... Bedingt
Iteratoren gültig? Referenzen gültig? Iteratoren gültig? Referenzen gültig?
Sequenz-Container array N/A N/A
vector Nein N/A Einfügung änderte Kapazität
Ja Ja Vor modifiziertem Element(en)
(für Einfügung nur wenn Kapazität unverändert)
Nein Nein An oder nach modifiziertem Element(en)
deque Nein Ja Ja, außer gelöschtem Element(en) Erstes oder letztes Element modifiziert
Nein Nein Nur mittleres Element modifiziert
list Ja Ja, außer gelöschtem Element(en)
forward_list Ja Ja, außer gelöschtem Element(en)
Assoziative Container set
multiset
map
multimap
Ja Ja, außer gelöschtem Element(en)
Ungeordnete assoziative Container unordered_set
unordered_multiset
unordered_map
unordered_multimap
Nein Ja N/A Einfügung verursachte Rehash
Ja Ja, außer gelöschtem Element(en) Kein Rehash

Hier bezieht sich insertion auf jede Methode, die ein oder mehrere Elemente zum Container hinzufügt, und erasure auf jede Methode, die ein oder mehrere Elemente aus dem Container entfernt.

(since C++11)

Sofern nicht anders angegeben (entweder explizit oder durch Definition einer Funktion in Bezug auf andere Funktionen), führt das Übergeben eines Containers als Argument an eine Bibliotheksfunktion niemals zur Ungültigkeit von Iteratoren oder zur Änderung der Werte von Objekten innerhalb dieses Containers.

Der Past-the-End-Iterator verdient besondere Erwähnung. Im Allgemeinen wird dieser Iterator ungültig, als ob es sich um einen normalen Iterator auf ein nicht gelöschtes Element handeln würde. Daher wird std::set::end niemals ungültig , std::unordered_set::end wird nur bei Rehash ungültig (since C++11) , std::vector::end wird immer ungültig (da es sich immer nach den modifizierten Elementen befindet), und so weiter.

Es gibt eine Ausnahme: Ein Löschvorgang, der das letzte Element eines std::deque macht den Past-the-End-Iterator ungültig, obwohl es sich nicht um ein gelöschtes Element des Containers handelt (oder überhaupt um ein Element). In Kombination mit den allgemeinen Regeln für std::deque Iteratoren ist das Endergebnis, dass die einzige modifizierende Operation, die nicht std::deque::end ungültig macht, ein Löschvorgang ist, der das erste Element löscht, aber nicht das letzte.

Thread-Sicherheit

  1. Alle Container-Funktionen können gleichzeitig von verschiedenen Threads auf verschiedenen Containern aufgerufen werden. Allgemeiner ausgedrückt: Die Funktionen der C++-Standardbibliothek lesen keine Objekte, auf die andere Threads zugreifen können, es sei denn, diese Objekte sind direkt oder indirekt über die Funktionsargumente (einschließlich des this-Zeigers) zugänglich.
  2. Alle const -Memberfunktionen können gleichzeitig von verschiedenen Threads auf demselben Container aufgerufen werden. Zusätzlich verhalten sich die Memberfunktionen begin() , end() , rbegin() , rend() , front() , back() , data() , find() , lower_bound() , upper_bound() , equal_range() , at() und (außer in assoziativen Containern) operator[] im Sinne der Thread-Sicherheit wie const -Funktionen (d.h. sie können ebenfalls gleichzeitig von verschiedenen Threads auf demselben Container aufgerufen werden). Allgemeiner ausgedrückt: Die Funktionen der C++-Standardbibliothek modifizieren keine Objekte, es sei denn, diese Objekte sind direkt oder indirekt über die nicht-konstanten Argumente der Funktion (einschließlich des this-Zeigers) zugänglich.
  3. Unterschiedliche Elemente desselben Containers können gleichzeitig von verschiedenen Threads modifiziert werden, mit Ausnahme der Elemente von std::vector<bool> (z.B. kann ein Vektor von std::future -Objekten Werte von mehreren Threads empfangen).
  4. Iterator-Operationen (z.B. das Inkrementieren eines Iterators) lesen den zugrundeliegenden Container, modifizieren ihn aber nicht und können gleichzeitig mit Operationen an anderen Iteratoren desselben Containers, mit const-Memberfunktionen oder mit Lesezugriffen auf die Elemente ausgeführt werden. Container-Operationen, die Iteratoren ungültig machen, modifizieren den Container und können nicht gleichzeitig mit Operationen an bestehenden Iteratoren ausgeführt werden, selbst wenn diese Iteratoren nicht ungültig werden.
  5. Elemente desselben Containers können gleichzeitig mit jenen Memberfunktionen modifiziert werden, die nicht spezifiziert sind, auf diese Elemente zuzugreifen. Allgemeiner ausgedrückt: Die Funktionen der C++-Standardbibliothek lesen keine indirekt über ihre Argumente zugänglichen Objekte (einschließlich anderer Elemente eines Containers), es sei denn, dies wird durch ihre Spezifikation erfordert.
  6. In jedem Fall können Container-Operationen (sowie Algorithmen oder andere C++-Standardbibliotheksfunktionen) intern parallelisiert werden, solange dies die für den Benutzer sichtbaren Ergebnisse nicht verändert (z.B. kann std::transform parallelisiert werden, nicht jedoch std::for_each , das spezifiziert ist, um jedes Element einer Sequenz in Reihenfolge zu besuchen).
(seit C++11)

Funktionstabelle

Hinweis: std::basic_string wird vom Standard nicht als Container behandelt, verhält sich jedoch aufgrund seiner Ähnlichkeit weitgehend wie einer. Es wird hier der Übersichtlichkeit halber als 'Pseudo-Container' aufgeführt.

- Funktionen vorhanden in C++03
- Funktionen vorhanden seit C++11
- Funktionen vorhanden seit C++17
- Funktionen vorhanden seit C++20
- Funktionen vorhanden seit C++23

Member-Funktionstabelle

**Erklärung:** - Der C++-Spezifikationsterm `unordered_multimap` wurde nicht übersetzt - HTML-Tags, Attribute und Formatierung bleiben unverändert - Die Übersetzung folgt den technischen Übersetzungsrichtlinien für C++-Dokumentation **Übersetzungserklärung:** - "capacity" wurde in den beiden äußeren Tabellenzellen als "Kapazität" übersetzt (deutsche Übersetzung für den allgemeinen Begriff) - Die "capacity"-Einträge innerhalb der ` `-Tags wurden nicht übersetzt, da es sich um C++-spezifische Begriffe handelt - Alle HTML-Tags, Attribute und Formatierungen wurden unverändert beibehalten - Die leeren ` `-Tags wurden ebenfalls unverändert gelassen **Anmerkung:** Der Text "prepend_range" wurde nicht übersetzt, da es sich um einen C++-spezifischen Begriff handelt, der gemäß den Anweisungen unverändert bleiben sollte. Die HTML-Struktur, Tags und Attribute wurden vollständig beibehalten. **Anmerkung:** Da der gesamte Text in diesem HTML-Fragment C++-spezifische Begriffe (`push_back`, `push`) enthält und diese innerhalb von ` `-Tags (die als Code-ähnlich betrachtet werden können) stehen, wurde gemäß den Anweisungen kein Text übersetzt. **Anmerkung:** Der Text "reverse" wurde nicht übersetzt, da es sich um einen C++-spezifischen Begriff handelt (Funktionsname in der Standardbibliothek). Alle HTML-Tags, Attribute und Formatierungen wurden unverändert beibehalten. **Anmerkung:** Der Text "sort" wurde nicht übersetzt, da es sich um einen C++-spezifischen Begriff handelt und innerhalb von ` `-Tags steht, die typischerweise für Code-Formatierung verwendet werden. **Übersetzungsdetails:** - "Bucket and Hash" wurde zu "Bucket und Hash" übersetzt - Alle HTML-Tags, Attribute und Formatierung wurden beibehalten - C++-spezifische Begriffe wie `begin(size_type)` und `cbegin(size_type)` wurden nicht übersetzt - Leere ` `-Tags wurden unverändert gelassen **Änderungen:** - "Adaptors" → "Adapter" (deutsche Standardübersetzung für diesen technischen Begriff) - Alle "extract"-Vorkommen bleiben unübersetzt (C++-spezifischer Begriff) - HTML-Tags, Attribute und Formatierung wurden vollständig beibehalten - Leere -Tags wurden nicht modifiziert
Pseudo-Container Sequenzcontainer Assoziative Container Ungeordnete assoziative Container Container-Adapter
Header <string> <array> <vector> <deque> <forward_list> <list> <set> <map> <unordered_set> <unordered_map> <stack> <queue> <flat_set> <flat_map> Header
Container
basic_string
array
vector
deque
forward_list
list
set
multiset
map
multimap
unordered_set
unordered_multiset
unordered_map
unordered_multimap
stack
queue
priority_queue
flat_set
flat_multiset
flat_map
flat_multimap
Container
(Konstruktor)
basic_string
(implizit)
vector
deque
forward_list
list
set
multiset
map
multimap
unordered_set
unordered_multiset
unordered_map
unordered_multimap
stack
queue
priority_queue
flat_set
flat_multiset
flat_map
flat_multimap
(Konstruktor)
(Destruktor)
~basic_string
(implizit)
~vector
~deque
~forward_list
~list
~set
~multiset
~map
~multimap
~unordered_set
~unordered_multiset
~unordered_map
~unordered_multimap
~stack
~queue
~priority_queue
~flat_set
~flat_multiset
~flat_map
~flat_multimap
(Destruktor)
operator=
operator=
(implizit)
operator=
operator=
operator=
operator=
operator=
operator=
operator=
operator=
operator=
operator=
operator=
operator=
operator=
operator=
operator=
operator=
operator=
operator=
operator=
operator=
assign
assign
assign
assign
assign
assign
assign
assign_range
assign_range
assign_range
assign_range
assign_range
assign_range
assign_range
Iteratoren
begin
cbegin
begin
cbegin
begin
cbegin
begin
cbegin
begin
cbegin
begin
cbegin
begin
cbegin
begin
cbegin
begin
cbegin
begin
cbegin
begin
cbegin
begin
cbegin
begin
cbegin
begin
cbegin
begin
cbegin
begin
cbegin
begin
cbegin
begin
cbegin
begin
cbegin
begin
cbegin
Iteratoren
Ende
cend
end
cend
end
cend
end
cend
end
cend
end
cend
end
cend
end
cend
end
cend
end
cend
end
cend
end
cend
end
cend
end
cend
end
cend
end
cend
end
cend
end
cend
end
cend
Ende
cend
rbegin
crbegin
rbegin
crbegin
rbegin
crbegin
rbegin
crbegin
rbegin
crbegin
rbegin
crbegin
rbegin
crbegin
rbegin
crbegin
rbegin
crbegin
rbegin
crbegin
rbegin
crbegin
rbegin
crbegin
rbegin
crbegin
rbegin
crbegin
rbegin
crbegin
rend
crend
rend
crend
rend
crend
rend
crend
rend
crend
rend
crend
rend
crend
rend
crend
rend
crend
rend
crend
rend
crend
rend
crend
rend
crend
rend
crend
rend
crend
Elementzugriff
at
at
at
at
at
at
at
at
at
Elementzugriff
operator[]
operator[]
operator[]
operator[]
operator[]
operator[]
operator[]
operator[]
operator[]
Daten
data
data
data
Daten
front
front
front
front
front
front
front
front
top
front
zurück
back
back
back
back
back
top
back
zurück
Kapazität
leer
empty
empty
empty
empty
empty
empty
leer
empty
empty
empty
empty
empty
empty
empty
empty
empty
empty
empty
empty
empty
empty
leer
Kapazität
Größe
size
size
size
size
size
size
size
size
size
size
size
size
size
size
size
size
size
size
size
size
Größe
max_size
max_size
max_size
max_size
max_size
max_size
max_size
max_size
max_size
max_size
max_size
max_size
max_size
max_size
max_size
max_size
max_size
max_size
max_size
max_size
resize
resize
resize
resize
resize
resize
resize
Kapazität
capacity
capacity
Kapazität
reserve
reserve
reserve
reserve
reserve
reserve
reserve
reserve
shrink_to_fit
shrink_to_fit
shrink_to_fit
shrink_to_fit
shrink_to_fit
Modifikatoren
clear
clear
clear
clear
clear
clear
clear
clear
clear
clear
clear
clear
clear
clear
clear
clear
clear
clear
clear
Modifikatoren
einfügen
einfügen
einfügen
einfügen
insert_after
einfügen
einfügen
einfügen
einfügen
einfügen
einfügen
einfügen
einfügen
einfügen
einfügen
einfügen
einfügen
einfügen
einfügen
insert_range
insert_range
insert_range
insert_range
insert_range_after
insert_range
insert_range
insert_range
insert_range
insert_range
insert_range
insert_range
insert_range
insert_range
insert_range
insert_range
insert_range
insert_range
insert_range
insert_or_assign
insert_or_assign
insert_or_assign
insert_or_assign
insert_or_assign
emplace
emplace
emplace
emplace_after
emplace
emplace
emplace
emplace
emplace
emplace
emplace
emplace
emplace
emplace
emplace
emplace
emplace
emplace
emplace_hint
emplace_hint
emplace_hint
emplace_hint
emplace_hint
emplace_hint
emplace_hint
emplace_hint
emplace_hint
emplace_hint
emplace_hint
emplace_hint
emplace_hint
emplace_hint
try_emplace
try_emplace
try_emplace
try_emplace
try_emplace
erase
erase
erase
erase
erase_after
erase
erase
erase
erase
erase
erase
erase
erase
erase
erase
erase
erase
erase
erase
push_front
push_front
push_front
push_front
push_front
prepend_range
prepend_range
prepend_range
prepend_range
prepend_range
emplace_front
emplace_front
emplace_front
emplace_front
emplace_front
pop_front
pop_front
pop_front
pop_front
pop
pop
pop_front
push_back
push_back
push_back
push_back
push_back
push
push
push
push_back
append_range
append_range
append_range
append_range
append_range
push_range
push_range
push_range
append_range
emplace_back
emplace_back
emplace_back
emplace_back
emplace
emplace
emplace
emplace_back
pop_back
pop_back
pop_back
pop_back
pop_back
pop
pop_back
swap
swap
swap
swap
swap
swap
swap
swap
swap
swap
swap
swap
swap
swap
swap
swap
swap
swap
swap
swap
swap
swap
swap
merge
merge
merge
merge
merge
merge
merge
merge
merge
merge
merge
merge
extract [1]
extract
extract
extract
extract
extract
extract
extract
extract
extract
Listenoperationen
splice
splice_after
splice
splice
Listenoperationen
remove
remove
remove
remove
remove_if
remove_if
remove_if
remove_if
reverse
reverse
reverse
reverse
unique
unique
unique
unique
sort
sort
sort
sort
Bucket und Hash
begin(size_type)
cbegin(size_type)
begin(size_type)
cbegin(size_type)
begin(size_type)
cbegin(size_type)
begin(size_type)
cbegin(size_type)
begin(size_type)
cbegin(size_type)
begin(size_type)
cbegin(size_type)
Bucket und Hash
end(size_type)
cend(size_type)
end(size_type)
cend(size_type)
end(size_type)
cend(size_type)
end(size_type)
cend(size_type)
end(size_type)
cend(size_type)
end(size_type)
cend(size_type)
bucket_count
bucket_count
bucket_count
bucket_count
bucket_count
bucket_count
max_bucket_count
max_bucket_count
max_bucket_count
max_bucket_count
max_bucket_count
max_bucket_count
bucket_size
bucket_size
bucket_size
bucket_size
bucket_size
bucket_size
bucket
bucket
bucket
bucket
bucket
bucket
load_factor
load_factor
load_factor
load_factor
load_factor
load_factor
max_load_factor
max_load_factor
max_load_factor
max_load_factor
max_load_factor
max_load_factor
rehash
rehash
rehash
rehash
rehash
rehash
Suche
count
count
count
count
count
count
count
count
count
count
count
count
count
count
Suche
find
find
find
find
find
find
find
find
find
find
find
find
find
find
find
enthält
enthält
enthält
enthält
enthält
enthält
enthält
enthält
enthält
enthält
enthält
enthält
enthält
enthält
enthält
lower_bound
lower_bound
lower_bound
lower_bound
lower_bound
lower_bound
lower_bound
lower_bound
lower_bound
lower_bound
upper_bound
upper_bound
upper_bound
upper_bound
upper_bound
upper_bound
upper_bound
upper_bound
upper_bound
upper_bound
equal_range
equal_range
equal_range
equal_range
equal_range
equal_range
equal_range
equal_range
equal_range
equal_range
equal_range
equal_range
equal_range
equal_range
Beobachter
key_comp
key_comp
key_comp
key_comp
key_comp
key_comp
key_comp
key_comp
key_comp
key_comp
Beobachter
value_comp
value_comp
value_comp
value_comp
value_comp
value_comp
value_comp
value_comp
value_comp
value_comp
hash_function
hash_function
hash_function
hash_function
hash_function
hash_function
key_eq
key_eq
key_eq
key_eq
key_eq
key_eq
Allocator
get_allocator
get_allocator
get_allocator
get_allocator
get_allocator
get_allocator
get_allocator
get_allocator
get_allocator
get_allocator
get_allocator
get_allocator
get_allocator
get_allocator
get_allocator
Allocator
Adapter
extract [2]
extract
extract
extract
extract
extract
Adapter
ersetzen
ersetzen
ersetzen
ersetzen
ersetzen
ersetzen
Container
basic_string
array
vector
deque
forward_list
list
set
multiset
map
multimap
unordered_set
unordered_multiset
unordered_map
unordered_multimap
stack
queue
priority_queue
flat_set
flat_multiset
flat_map
flat_multimap
Container
Header <string> <array> <vector> <deque> <forward_list> <list> <set> <map> <unordered_set> <unordered_map> <stack> <queue> <flat_set> <flat_map> Header
Pseudo-Container Sequenzcontainer Assoziative Container Ungeordnete assoziative Container Container-Adapter
  • Hinweis: Funktionen in zwei verschiedenen extract Zeilen haben unterschiedliche Bedeutungen und Syntax:
  1. z.B., node_type extract ( const_iterator ) oder node_type extract ( Key & )
  2. z.B., container_type extract ( ) &&

Tabelle der Nicht-Mitgliedsfunktionen

**Erklärung:** - Der C++-Operator `operator==` wurde nicht übersetzt, da es sich um einen C++-spezifischen Begriff handelt - HTML-Tags, Attribute und Formatierung wurden vollständig beibehalten - Der Text innerhalb des ` `-Tags (C++-Code) blieb unverändert - Die Übersetzung folgt den professionellen Standards für technische Dokumentation
Pseudo-Container Sequenzcontainer Assoziative Container Ungeordnete assoziative Container Container-Adapter
Header <string> <array> <vector> <deque> <forward_list> <list> <set> <map> <unordered_set> <unordered_map> <stack> <queue> <flat_set> <flat_map> Header
Container
basic_string
array
vector
deque
forward_list
list
set
multiset
map
multimap
unordered_set
unordered_multiset
unordered_map
unordered_multimap
stack
queue
priority_queue
flat_set
flat_multiset
flat_map
flat_multimap
Container
Nicht-Member-Funktion
operator==
operator==
operator==
operator==
operator==
operator==
operator==
operator==
operator==
operator==
operator==
operator==
operator==
operator==
operator==
operator==
operator==
operator==
operator==
operator==
operator==
operator==
Nicht-Member-Funktion
operator!= (entfernt in C++20)
operator!=
operator!=
operator!=
operator!=
operator!=
operator!=
operator!=
operator!=
operator!=
operator!=
operator!=
operator!=
operator!=
operator!=
operator!=
operator!=
operator!= (entfernt in C++20)
operator< (entfernt in C++20)
operator<
operator<
operator<
operator<
operator<
operator<
operator<
operator<
operator<
operator<
operator<
operator<
operator< (entfernt in C++20)
operator<= (entfernt in C++20)
operator<=
operator<=
operator<=
operator<=
operator<=
operator<=
operator<=
operator<=
operator<=
operator<=
operator<=
operator<=
operator<= (entfernt in C++20)
operator> (entfernt in C++20)
operator>
operator>
operator>
operator>
operator>
operator>
operator>
operator>
operator>
operator>
operator>
operator>
operator> (entfernt in C++20)
operator>= (in C++20 entfernt)
operator>=
operator>=
operator>=
operator>=
operator>=
operator>=
operator>=
operator>=
operator>=
operator>=
operator>=
operator>=
operator>= (in C++20 entfernt)
operator<=>
operator<=>
operator<=>
operator<=>
operator<=>
operator<=>
operator<=>
operator<=>
operator<=>
operator<=>
operator<=>
operator<=>
operator<=>
operator<=>
operator<=>
operator<=>
operator<=>
operator<=>
swap
swap
swap
swap
swap
swap
swap
swap
swap
swap
swap
swap
swap
swap
swap
swap
swap
swap
swap
swap
swap
swap
swap
erase
erase
erase
erase
erase
erase
erase
erase_if
erase_if
erase_if
erase_if
erase_if
erase_if
erase_if
erase_if
erase_if
erase_if
erase_if
erase_if
erase_if
erase_if
erase_if
erase_if
erase_if
erase_if
erase_if
Container
basic_string
array
vector
deque
forward_list
list
set
multiset
map
multimap
unordered_set
unordered_multiset
unordered_map
unordered_multimap
stack
queue
priority_queue
flat_set
flat_multiset
flat_map
flat_multimap
Container
Header <string> <array> <vector> <deque> <forward_list> <list> <set> <map> <unordered_set> <unordered_map> <stack> <queue> <flat_set> <flat_map> Header
Pseudo-Container Sequenzcontainer Assoziative Container Ungeordnete assoziative Container Container-Adapter

Die Operatoren < , <= , > , >= und != werden synthetisiert aus operator <=> bzw. operator == .

(since C++20)

Fehlerberichte

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

DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
LWG 51 C++98 Container-Iteratoren könnten ungültig werden
durch beliebige Bibliotheksoperation
sie werden nur ungültig
wenn spezifiziert

Siehe auch

C++ benannte Anforderungen:

Numerische Arrays, Array-Masken und Array-Slices
(Klassentemplate)
Speichert und manipuliert Zeichensequenzen
(Klassentemplate)
Schreibgeschützte String-Ansicht
(Klassentemplate)