Container-Bibliothek

 

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

 

Die Containers-Bibliothek ist eine generische Sammlung von Klassenvorlagen und Algorithmen, die es Programmierern ermöglicht, gängige Datenstrukturen wie Queues, Listen und Stacks einfach zu implementieren. Es gibt zwei(bis C++11)drei(seit C++11) Arten von Containern: Sequenzcontainer, assoziative Container und ungeordnete assoziative Container, von denen jeder für eine andere Menge von Operationen ausgelegt ist.

• Sequenzcontainer,
• assoziative Container,

ungeordnete assoziative Container,

(seit C++11)

von denen jeder für eine andere Menge von Operationen ausgelegt ist.

Der Container verwaltet den für seine Elemente zugewiesenen Speicherplatz und stellt Mitgliedsfunktionen zum Zugriff darauf bereit, entweder direkt oder über Iteratoren (Objekte mit Zeiger-ähnlichen Eigenschaften).

Die meisten Container haben mindestens mehrere gemeinsame Mitgliedsfunktionen und teilen sich Funktionalitäten. Welcher Container für die jeweilige Anwendung am besten geeignet ist, hängt nicht nur von der angebotenen Funktionalität ab, sondern auch von seiner Effizienz bei verschiedenen Arbeitslasten.

Sequenzcontainer

Sequenzcontainer implementieren Datenstrukturen, auf die sequenziell zugegriffen werden kann.

array (C++11)	fest dimensioniertes, inplace, zusammenhängendes Array (Klassenvorlage)
vector	reservierbares, zusammenhängendes Array (Klassenvorlage)
inplace_vector (C++26)	reservierbares, festes Kapazitäts-Array, Inplace, zusammenhängend (Klassenvorlage)
hive (C++26)	Sammlung, die den Speicher von gelöschten Elementen wiederverwendet (Klassenvorlage)
deque	Doppelt-endende Warteschlange (Klassenvorlage)
forward_list (C++11)	Einfach verkettete Liste (Klassenvorlage)
list	Doppelt verkettete Liste (Klassenvorlage)

Assoziative Container

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

setzt	Sammlung eindeutiger Schlüssel, sortiert nach Schlüsseln (Klassenvorlage)
map	Sammlung von Schlüssel-Wert-Paaren, sortiert nach Schlüsseln, Schlüssel sind eindeutig (Klassenvorlage)
multiset	Sammlung von Schlüsseln, sortiert nach Schlüsseln (Klassenvorlage)
multimap	Sammlung von Schlüssel-Wert-Paaren, sortiert nach Schlüsseln (Klassenvorlage)

Ungeordnete assoziative Container (seit C++11)

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

unordered_set (C++11)	Sammlung eindeutiger Schlüssel, gehasht nach Schlüsseln (Klassenvorlage)
unordered_map (C++11)	Sammlung von Schlüssel-Wert-Paaren, gehasht nach Schlüsseln, Schlüssel sind eindeutig (Klassenvorlage)
unordered_multiset (C++11)	Sammlung von Schlüsseln, gehasht nach Schlüsseln (Klassenvorlage)
unordered_multimap (C++11)	Sammlung von Schlüssel-Wert-Paaren, gehasht nach Schlüsseln (Klassenvorlage)

Container-Adapter

Container-Adapter bieten eine andere Schnittstelle für Sequenzcontainer.

stack	passt einen Container an, um einen Stack (LIFO-Datenstruktur) bereitzustellen (Klassenvorlage)
queue	passt einen Container an, um eine Queue (FIFO-Datenstruktur) bereitzustellen (Klassenvorlage)
priority_queue	passt einen Container an, um eine Prioritätswarteschlange bereitzustellen (Klassenvorlage)
flat_set (C++23)	passt einen Container an, um eine Sammlung eindeutiger Schlüssel, sortiert nach Schlüsseln, bereitzustellen (Klassenvorlage)
flat_map (C++23)	passt zwei Container an, um eine Sammlung von Schlüssel-Wert-Paaren, sortiert nach eindeutigen Schlüsseln, bereitzustellen (Klassenvorlage)
flat_multiset (C++23)	passt einen Container an, um eine Sammlung von Schlüsseln, sortiert nach Schlüsseln, bereitzustellen (Klassenvorlage)
flat_multimap (C++23)	passt zwei Container an, um eine Sammlung von Schlüssel-Wert-Paaren, sortiert nach Schlüsseln, bereitzustellen (Klassenvorlage)

Views (seit C++20)

Views bieten flexible Einrichtungen zur Interaktion mit ein- oder mehrdimensionalen Views über ein nicht-besitzendes Array von Elementen.

span (C++20)	eine nicht besitzende Ansicht über eine zusammenhängende Sequenz von Objekten (class template)
mdspan (C++23)	eine mehrdimensionale, nicht-besitzende Array-View (Klassenvorlage)

Iterator-Invalidierung

Nur-Lese-Methoden invalidieren niemals Iteratoren oder Referenzen. Methoden, die den Inhalt eines Containers ä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?
Sequenzcontainer	array	N/A		N/A
	vector	Nein		N/A		Einfügung hat Kapazität geändert
		Ja		Ja		Vor dem/den modifizierten Element(en) (bei Einfügung nur, wenn Kapazität sich nicht geändert hat)
		Nein		Nein		Bei oder nach dem/den modifizierten Element(en)
	deque	Nein	Ja	Ja, außer gelöschte(n) Element(e)		Erstes oder letztes Element modifiziert
			Nein	Nein		Nur mittleres Element modifiziert
	list	Ja		Ja, außer gelöschte(n) Element(e)
	forward_list	Ja		Ja, außer gelöschte(n) Element(e)
Assoziative Container	setzt multiset map multimap	Ja		Ja, außer gelöschte(n) Element(e)
Ungeordnete assoziative Container	unordered_set unordered_multiset unordered_map unordered_multimap	Nein	Ja	N/A		Einfügung hat Rehash verursacht
		Ja		Ja, außer gelöschte(n) Element(e)		Kein Rehash

Hier bezieht sich Einfügung auf jede Methode, die ein oder mehrere Elemente zum Container hinzufügt, und Löschung bezieht sich auf jede Methode, die ein oder mehrere Elemente aus dem Container entfernt.

• Beispiele für Einfügungsmethoden sind std::set::insert, std::map::emplace, std::vector::push_back und std::deque::push_front.

Beachten Sie, dass auch std::unordered_map::operator[] dazu zählt, da es ein Element in die Map einfügen kann.

(seit C++11)

• Beispiele für Löschungsmethoden sind std::set::erase, std::vector::pop_back, std::deque::pop_front und std::map::clear.
  • clear macht alle Iteratoren und Referenzen ungültig. Da es alle Elemente löscht, entspricht dies technisch den obigen Regeln.

Sofern nicht anders angegeben (entweder explizit oder durch Definition einer Funktion in Bezug auf andere Funktionen), macht das Übergeben eines Containers als Argument an eine Bibliotheksfunktion niemals Iteratoren zu oder ändert die Werte von Objekten innerhalb dieses Containers.

Der Past-the-End-Iterator verdient besondere Erwähnung. Im Allgemeinen wird dieser Iterator so behandelt, als ob er ein normaler Iterator zu einem nicht gelöschten Element wäre. Daher wird std::set::end niemals ungültig gemacht, std::unordered_set::end wird nur bei Rehash ungültig gemacht(seit C++11), std::vector::end wird immer ungültig gemacht (da er sich immer hinter den modifizierten Elementen befindet) und so weiter.

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

Thread-Sicherheit Alle Containerfunktionen können von verschiedenen Threads auf verschiedenen Containern gleichzeitig aufgerufen werden. Allgemeiner gesagt, lesen die C++-Standardbibliotheksfunktionen keine Objekte, auf die von anderen Threads zugegriffen werden kann, es sei denn, diese Objekte sind direkt oder indirekt über die Funktionsargumente, einschließlich des this-Zeigers, zugänglich. Alle const-Mitgliedsfunktionen können von verschiedenen Threads auf demselben Container gleichzeitig aufgerufen werden. Zusätzlich verhalten sich die Mitgliedsfunktionen begin(), end(), rbegin(), rend(), front(), back(), data(), find(), lower_bound(), upper_bound(), equal_range(), at() und (außer in assoziativen Containern) operator[] für die Thread-Sicherheit wie const (d. h., sie können auch von verschiedenen Threads auf demselben Container gleichzeitig aufgerufen werden). Allgemeiner gesagt, ändern die C++-Standardbibliotheksfunktionen keine Objekte, es sei denn, diese Objekte sind direkt oder indirekt über die Nicht-const-Argumente der Funktion, einschließlich des this-Zeigers, zugänglich. Verschiedene Elemente im selben Container können von verschiedenen Threads gleichzeitig modifiziert werden, mit Ausnahme der Elemente von std::vector<bool> (z. B. kann ein Vektor von std::future-Objekten Werte von mehreren Threads empfangen). Iterator-Operationen (z. B. das Inkrementieren eines Iterators) lesen, aber modifizieren nicht den zugrunde liegenden Container und können gleichzeitig mit Operationen auf anderen Iteratoren desselben Containers, mit den const-Mitgliedsfunktionen oder mit Lesevorgängen auf den Elementen ausgeführt werden. Containeroperationen, die Iteratoren ungültig machen, modifizieren den Container und können nicht gleichzeitig mit Operationen auf vorhandenen Iteratoren ausgeführt werden, selbst wenn diese Iteratoren nicht ungültig sind. Elemente desselben Containers können gleichzeitig mit den Mitgliedsfunktionen modifiziert werden, die nicht angegeben sind, diese Elemente zu verarbeiten. Allgemeiner gesagt, lesen die C++-Standardbibliotheksfunktionen keine Objekte, die indirekt über ihre Argumente zugänglich sind (einschließlich anderer Elemente eines Containers), es sei denn, dies ist durch ihre Spezifikation erforderlich. In jedem Fall können Containeroperationen (sowie Algorithmen oder andere C++-Standardbibliotheksfunktionen) intern parallelisiert werden, solange dies die für den Benutzer sichtbaren Ergebnisse nicht ändert (z. B. kann std::transform parallelisiert werden, aber nicht std::for_each, das spezifiziert ist, jedes Element einer Sequenz in Ordnung zu besuchen).

(seit C++11)

Funktionstabelle

Hinweis: std::basic_string wird vom Standard nicht als Container behandelt, verhält sich aber aufgrund seiner Ähnlichkeit stark wie einer. Er ist hier der Bequemlichkeit halber als 'Pseudo-Container' aufgeführt.

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

Mitgliedsfunktionstabelle

		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	setzt	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	setzt	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
	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	end cend	end 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
Element Zugriff	at	at	at	at	at					at				at							at		at	Element Zugriff
	operator[]	operator[]	operator[]	operator[]	operator[]					operator[]				operator[]							operator[]		operator[]
	data	data	data	data																			data
	front	front	front	front	front	front	front										front	top					front
	back	back	back	back	back		back									top	back						back
Kapazität	empty	empty	empty	empty	empty	empty	empty	empty	empty	empty	empty	empty	empty	empty	empty	empty	empty	empty	empty	empty	empty	empty	empty	Kapazität
	size	size	size	size	size		size	size	size	size	size	size	size	size	size	size	size	size	size	size	size	size	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	max_size
	resize	resize		resize	resize	resize	resize																resize
	capacity	capacity		capacity																			capacity
	reserve	reserve		reserve								reserve	reserve	reserve	reserve								reserve
	shrink_to_fit	shrink_to_fit		shrink_to_fit	shrink_to_fit																		shrink_to_fit
Modifizierer	clear	clear		clear	clear	clear	clear	clear	clear	clear	clear	clear	clear	clear	clear				clear	clear	clear	clear	clear	Modifizierer
	insert	insert		insert	insert	insert_after	insert	insert	insert	insert	insert	insert	insert	insert	insert				insert	insert	insert	insert	insert
	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							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	zählt							zählt	zählt	zählt	zählt	zählt	zählt	zählt	zählt				zählt	zählt	zählt	zählt	zählt	Suche
	find	find						find	find	find	find	find	find	find	find				find	find	find	find	find
	contains	contains						contains	contains	contains	contains	contains	contains	contains	contains				contains	contains	contains	contains	contains
	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
Observer	key_comp							key_comp	key_comp	key_comp	key_comp								key_comp	key_comp	key_comp	key_comp	key_comp	Observer
	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																		extract	extract	extract	extract	extract	Adapter
	replace																		replace	replace	replace	replace	replace
Container		basic_string	array	vector	deque	forward_list	list	setzt	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

Nicht-Mitgliedsfunktionstabelle

		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	setzt	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-Mitgliedsfunktion	operator==	operator==	operator==	operator==	operator==	operator==	operator==	operator==	operator==	operator==	operator==	operator==	operator==	operator==	operator==	operator==	operator==		operator==	operator==	operator==	operator==	operator==	Nicht-Mitgliedsfunktion
	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>= (entfernt in C++20)	operator>=	operator>=	operator>=	operator>=	operator>=	operator>=	operator>=	operator>=	operator>=	operator>=					operator>=	operator>=						operator>= (entfernt in C++20)
	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	setzt	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 != sind synthetisiert aus operator<=> und operator== beziehungsweise.

(seit C++20)

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 51	C++98	Container-Iteratoren könnten ungültig gemacht werden durch beliebige Bibliotheksoperationen	sie werden nur ungültig gemacht wenn angegeben

Siehe auch

C++ benannte Anforderungen

• Container
• SequenceContainer
• ContiguousContainer
• ReversibleContainer
• AssociativeContainer
• AllocatorAwareContainer
• UnorderedAssociativeContainer

valarray	numerische Arrays, Array-Masken und Array-Slices (Klassenvorlage)
basic_string	speichert und manipuliert Zeichenfolgen (Klassenvorlage)
basic_string_view (C++17)	schreibgeschützte String-Ansicht (class template)