Iterator-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

 

Iterator-Bibliothek

Iterator-Konzepte
indirectly_readable (C++20) indirectly_writable (C++20) weakly_incrementable (C++20) incrementable (C++20) is-integer-like is-signed-integer-like (C++20)(C++20)	sentinel_for (C++20) sized_sentinel_for (C++20) input_iterator (C++20) output_iterator (C++20) input_or_output_iterator (C++20)	forward_iterator (C++20) bidirectional_iterator (C++20) random_access_iterator (C++20) contiguous_iterator (C++20)
Iterator-Primitive
input_iterator_tagoutput_iterator_tagforward_iterator_tagbidirectional_iterator_tagrandom_access_iterator_tagcontiguous_iterator_tag (C++20)	iter_value_titer_difference_titer_reference_titer_const_reference_titer_rvalue_reference_titer_common_reference_t (C++20)(C++20)(C++20)(C++23)(C++20)(C++20)	iterator (veraltet in C++17) iterator_traits incrementable_traits (C++20) indirectly_readable_traits (C++20)
Algorithmus-Konzepte und Hilfsprogramme
Indirekte aufrufbare Konzepte
indirectly_unary_invocableindirectly_regular_unary_invocable (C++20)(C++20)	indirect_unary_predicate (C++20) indirect_binary_predicate (C++20)	indirect_equivalence_relation (C++20) indirect_strict_weak_order (C++20)
Gemeinsame Algorithmus-Anforderungen
indirectly_movable (C++20) indirectly_movable_storable (C++20) indirectly_copyable (C++20)	indirectly_copyable_storable (C++20)   indirectly_swappable (C++20) indirectly_comparable (C++20)	permutable (C++20) mergeable (C++20) sortable (C++20)
Dienstprogramme
indirect_result_t (C++20)	projected (C++20)	projected_value_t (C++26)
Iterator-Adapter
reverse_iterator make_reverse_iterator (C++14) move_iterator (C++11) make_move_iterator (C++11) default_sentinel_tdefault_sentinel (C++20)(C++20) unreachable_sentinel_tunreachable_sentinel (C++20)(C++20)	front_insert_iterator back_insert_iterator inserter insert_iterator front_inserter back_inserter move_sentinel (C++20)	common_iterator (C++20) counted_iterator (C++20) basic_const_iterator (C++23) const_iterator (C++23) const_sentinel (C++23) make_const_iterator (C++23) make_const_sentinel (C++23)
Stream-Iteratoren istream_iterator    ostream_iterator istreambuf_iterator ostreambuf_iterator	Iterator-Anpassungspunkte ranges::iter_move (C++20) ranges::iter_swap (C++20)
Iterator-Operationen advance distance prev (C++11)   next (C++11) ranges::advance (C++20) ranges::distance (C++20) ranges::prev (C++20) ranges::next (C++20)	Bereichszugriff begincbegin (C++11)(C++14) rbegincrbegin (C++14)(C++14)   endcend (C++11)(C++14) rendcrend (C++14)(C++14)   sizessize (C++17)(C++20) empty (C++17) data (C++17)

 

Iteratoren sind eine Verallgemeinerung von Zeigern, die es einem C++-Programm ermöglichen, mit verschiedenen Datenstrukturen (z. B. Containern und Ranges(seit C++20)) auf einheitliche Weise zu arbeiten. Die Iterator-Bibliothek stellt Definitionen für Iteratoren sowie Iterator-Traits, -Adapter und Hilfsfunktionen bereit.

Da Iteratoren eine Abstraktion von Zeigern sind, verallgemeinert ihre Semantik die meisten Zeigersemantiken in C++. Dies stellt sicher, dass jede Funktionsschablone, die Iteratoren verwendet, auch mit normalen Zeigern funktioniert.

Iterator-Kategorien

Es gibt fünf(bis C++17)sechs(seit C++17) Arten von Iteratoren: LegacyInputIterator, LegacyOutputIterator, LegacyForwardIterator, LegacyBidirectionalIterator, LegacyRandomAccessIterator und LegacyContiguousIterator(seit C++17). (Siehe auch LegacyIterator für die grundlegendste Iterator-Art.)

Anstatt durch bestimmte Typen definiert zu werden, wird jede Iterator-Kategorie durch die Operationen definiert, die auf sie angewendet werden können. Diese Definition bedeutet, dass jeder Typ, der die notwendigen Operationen unterstützt, als Iterator verwendet werden kann – beispielsweise unterstützt ein Zeiger alle für LegacyRandomAccessIterator erforderlichen Operationen, sodass ein Zeiger überall dort verwendet werden kann, wo ein LegacyRandomAccessIterator erwartet wird.

Alle Iterator-Kategorien (außer LegacyOutputIterator) können in einer Hierarchie organisiert werden, in der leistungsfähigere Iterator-Kategorien (z. B. LegacyRandomAccessIterator) die Operationen weniger leistungsfähiger Kategorien (z. B. LegacyInputIterator) unterstützen. Wenn ein Iterator in eine dieser Kategorien fällt und auch die Anforderungen von LegacyOutputIterator erfüllt, dann wird er als *mutable* Iterator bezeichnet und unterstützt *sowohl* Eingabe als auch Ausgabe. Nicht-mutable Iteratoren werden als *const* Iteratoren bezeichnet.

Iteratoren werden als *constexpr*-Iteratoren bezeichnet, wenn alle zur Erfüllung der Iterator-Kategorie-Anforderungen bereitgestellten Operationen constexpr-Funktionen sind.

(seit C++20)

Iterator-Kategorie	Operationen und Speicheranforderung
	schreiben	lesen	Inkrement		dekrementieren	zufällig    Zugriff	zusammenhängend  Speicher
			ohne    mehrere    Durchgänge	mit    mehrere    Durchgänge
LegacyIterator			Erforderlich
LegacyOutputIterator	Erforderlich		Erforderlich
LegacyInputIterator (mutable, falls Schreiboperation unterstützt wird)		Erforderlich	Erforderlich
LegacyForwardIterator (erfüllt auch LegacyInputIterator)		Erforderlich	Erforderlich	Erforderlich
LegacyBidirectionalIterator (erfüllt auch LegacyForwardIterator)		Erforderlich	Erforderlich	Erforderlich	Erforderlich
LegacyRandomAccessIterator (erfüllt auch LegacyBidirectionalIterator)		Erforderlich	Erforderlich	Erforderlich	Erforderlich	Erforderlich
LegacyContiguousIterator (erfüllt auch LegacyRandomAccessIterator)		Erforderlich	Erforderlich	Erforderlich	Erforderlich	Erforderlich	Erforderlich

Hinweis: Ein Typ, der die erforderlichen Operationen in einer Zeile der obigen Tabelle unterstützt, fällt nicht unbedingt in die entsprechende Kategorie. Eine vollständige Liste der Anforderungen finden Sie auf der Kategorie-Seite.

Definitionen

Typen und Schreibbarkeit

Ein Eingabeiterator i unterstützt den Ausdruck *i, der einen Wert eines beliebigen Objekttyps T ergibt, der als *Werttyp* des Iterators bezeichnet wird.

Ein Ausgabeiterator i hat eine nicht-leere Menge von Typen, die in den Iterator *geschrieben* werden können(bis C++20)indirectly_writable(seit C++20); für jeden solchen Typ T ist der Ausdruck *i = o gültig, wobei o ein Wert vom Typ T ist.

Für jeden Iteratortyp X, für den Gleichheit definiert ist(bis C++20), gibt es einen zugehörigen vorzeichenbehafteten Ganzzahltyp(bis C++20)ganzzahlähnlichen(seit C++20) Typ, der als *Differenztyp* des Iterators bezeichnet wird.

Dereferenzierbarkeit und Gültigkeit

So wie ein regulärer Zeiger auf ein Array garantiert, dass es einen Zeigerwert gibt, der hinter das letzte Element des Arrays zeigt, so gibt es auch für jeden Iteratortyp einen Iteratorwert, der hinter das letzte Element einer entsprechenden Sequenz zeigt. Ein solcher Wert wird als *Past-the-end*-Wert bezeichnet.

Werte eines Iterators i, für die der Ausdruck *i definiert ist, werden als *dereferenzierbar* bezeichnet. Die Standardbibliothek geht niemals davon aus, dass Past-the-end-Werte dereferenzierbar sind.

Iteratoren können auch *singuläre* Werte haben, die nicht mit einer Sequenz verbunden sind. Die Ergebnisse der meisten Ausdrücke sind für singuläre Werte undefiniert; die einzigen Ausnahmen sind

• die Zuweisung eines nicht-singulären Wertes an einen Iterator, der einen singulären Wert enthält,
• die Zerstörung eines Iterators, der einen singulären Wert enthält, und
• für Iteratoren, die die Anforderungen von DefaultConstructible erfüllen, die Verwendung eines wertinitialisierten Iterators als Quelle einer Kopier-oder Verschiebungsoperation(seit C++11).

In diesen Fällen wird der singuläre Wert genauso überschrieben wie jeder andere Wert. Dereferenzierbare Werte sind immer nicht-singulär.

Ein *ungültiger* Iterator ist ein Iterator, der singulär sein kann.

Bereiche

Die meisten algorithmischen Templates der Standardbibliothek, die auf Datenstrukturen operieren, haben Schnittstellen, die Bereiche verwenden.

Ein Iterator j wird als von einem Iterator i *erreichbar* bezeichnet, wenn und nur wenn eine endliche Folge von Anwendungen des Ausdrucks ++i dazu führt, dass i == j. Wenn j von i erreichbar ist, beziehen sie sich auf Elemente derselben Sequenz. Ein *Bereich* ist ein Paar von Iteratoren, die den Anfang und das Ende der Berechnung bezeichnen. Ein Bereich [i, i) ist ein leerer Bereich; im Allgemeinen bezieht sich ein Bereich [i, j) auf die Elemente in der Datenstruktur, beginnend mit dem Element, auf das i zeigt, bis zu, aber nicht einschließlich, dem Element, auf das j zeigt. Der Bereich [i, j) ist *gültig*, wenn und nur wenn j von i erreichbar ist.

(bis C++20)

Ein *Bereich* kann bezeichnet werden durch [i, s), mit einem Iterator i und einem *Sentinel* s, die den Anfang und das Ende der Berechnung bezeichnen (i und s können unterschiedliche Typen haben), oder i + [​0​, n), mit einem Iterator i und einer Anzahl n, die den Anfang und die Anzahl der Elemente bezeichnen, auf die die Berechnung angewendet werden soll. Iterator-Sentinel-Bereich Ein Iterator und ein Sentinel, die einen Bereich bezeichnen, sind vergleichbar. [i, s) ist leer, wenn i == s; andernfalls bezeichnet [i, s) die Elemente in der Datenstruktur, beginnend mit dem Element, auf das i zeigt, bis zu, aber nicht einschließlich, dem Element, auf das der erste Iterator j zeigt, für das j == s gilt. Ein Sentinel s wird von einem Iterator i als *erreichbar* bezeichnet, wenn und nur wenn eine endliche Folge von Anwendungen des Ausdrucks ++i dazu führt, dass i == s. Wenn s von i erreichbar ist, bezeichnet [i, s) einen *gültigen* Bereich. Gezählter Bereich Ein *gezählter Bereich* i + [​0​, n) ist leer, wenn n == 0; andernfalls bezeichnet i + [​0​, n) die n Elemente in der Datenstruktur, beginnend mit dem Element, auf das i zeigt, bis zu, aber nicht einschließlich, dem Element, auf das das Ergebnis von n Anwendungen von ++i zeigt. Ein gezählter Bereich i + [​0​, n) ist *gültig*, wenn und nur wenn n == 0; oder alle folgenden Bedingungen erfüllt sind n positiv ist, i dereferenzierbar ist und ++i + [​0​, --n) gültig ist.

(seit C++20)

Das Ergebnis der Anwendung von Funktionen in der Standardbibliothek auf ungültige Bereiche ist undefiniert.

Iterator-Konzepte (seit C++20)

Ein neues System von Iteratoren, das auf Konzepten basiert, das sich von C++17-Iteratoren unterscheidet. Während die grundlegende Taxonomie ähnlich bleibt, unterscheiden sich die Anforderungen an die einzelnen Iterator-Kategorien leicht.

Definiert im Namespace std
indirectly_readable (C++20)	spezifiziert, dass ein Typ durch Anwendung des Operators * indirekt lesbar ist (Konzept)
indirectly_writable (C++20)	spezifiziert, dass ein Wert in das von einem Iterator referenzierte Objekt geschrieben werden kann (Konzept)
weakly_incrementable (C++20)	spezifiziert, dass ein semiregular-Typ mit Prä- und Post-Inkrementoperatoren inkrementiert werden kann (Konzept)
incrementable (C++20)	spezifiziert, dass die Inkrementoperation auf einem weakly_incrementable-Typ *gleichheitserhaltend* ist und dass der Typ equality_comparable ist (Konzept)
is-integer-likeis-signed-integer-like (C++20)(C++20)	spezifiziert, dass ein Typ sich wie ein (vorzeichenbehafteter) Ganzzahltyp verhält (exposition-only Konzept*)
input_or_output_iterator (C++20)	spezifiziert, dass Objekte eines Typs inkrementiert und dereferenziert werden können (Konzept)
sentinel_for (C++20)	spezifiziert, dass ein Typ ein Sentinel für einen input_or_output_iterator-Typ ist (Konzept)
sized_sentinel_for (C++20)	spezifiziert, dass der Operator - auf einen Iterator und ein Sentinel angewendet werden kann, um ihre Differenz in konstanter Zeit zu berechnen (Konzept)
input_iterator (C++20)	spezifiziert, dass ein Typ ein Eingabeiterator ist, d. h. seine referenzierten Werte können gelesen werden und er kann sowohl prä- als auch post-inkrementiert werden (Konzept)
output_iterator (C++20)	spezifiziert, dass ein Typ ein Ausgabeiterator für einen gegebenen Werttyp ist, d. h. Werte dieses Typs können hineingeschrieben werden und er kann sowohl prä- als auch post-inkrementiert werden (Konzept)
forward_iterator (C++20)	spezifiziert, dass ein input_iterator ein Vorwärtsiterator ist, der Gleichheitsvergleich und Multi-Pass unterstützt (Konzept)
bidirectional_iterator (C++20)	spezifiziert, dass ein forward_iterator ein bidirektionaler Iterator ist, der die Rückwärtsbewegung unterstützt (Konzept)
random_access_iterator (C++20)	spezifiziert, dass ein bidirectional_iterator ein Zufallszugriff-Iterator ist, der die Vorwärtsbewegung in konstanter Zeit und Indizierung unterstützt (Konzept)
contiguous_iterator (C++20)	spezifiziert, dass ein random_access_iterator ein zusammenhängender Iterator ist, der auf Speicherbereiche verweist, die im Speicher zusammenhängend sind (Konzept)

Iterator-zugeordnete Typen (seit C++20)

Definiert im Namespace std
incrementable_traits (C++20)	berechnet den Differenztyp eines weakly_incrementable-Typs (Klassenschablone)
indirectly_readable_traits (C++20)	berechnet den Werttyp eines indirectly_readable-Typs (Klassenschablone)
iter_value_titer_reference_titer_const_reference_titer_difference_titer_rvalue_reference_titer_common_reference_t (C++20)(C++20)(C++23)(C++20)(C++20)(C++20)	berechnet die zugehörigen Typen eines Iterators (Alias-Schablone)

Iterator-Primitive

iterator_traits	bietet eine einheitliche Schnittstelle zu den Eigenschaften eines Iterators (Klassenschablone)
input_iterator_tagoutput_iterator_tagforward_iterator_tagbidirectional_iterator_tagrandom_access_iterator_tagcontiguous_iterator_tag (C++20)	leere Klassentypen, die zur Angabe von Iterator-Kategorien verwendet werden (Klasse)
iterator (veraltet in C++17)	Basisklasse zur Vereinfachung der Definition der erforderlichen Typen für einfache Iteratoren (Klassenschablone)

Iterator-Anpassungspunkte (seit C++20)

Definiert im Namespace std::ranges
iter_move (C++20)	wandelt das Ergebnis der Dereferenzierung eines Objekts in seinen zugehörigen rvalue-Referenztyp um (Anpassungspunkt-Objekt)
iter_swap (C++20)	tauscht die von zwei dereferenzierbaren Objekten referenzierten Werte (Customization-Punkt-Objekt)

Konzept- und Hilfsoperatoren (seit C++20)

Eine Menge von Konzepten und zugehörigen Hilfsvorlagen, die dazu dienen, gängige Algorithmusoperationen einfacher einzuschränken.

Definiert in Header <iterator>
Definiert im Namespace std
Indirekte aufrufbare Konzepte
indirectly_unary_invocableindirectly_regular_unary_invocable (C++20)(C++20)	spezifiziert, dass ein aufrufbaren Typ mit dem Ergebnis der Dereferenzierung eines indirectly_readable Typs aufgerufen werden kann (Konzept)
indirect_unary_predicate (C++20)	spezifiziert, dass ein aufrufbaren Typ, wenn er mit dem Ergebnis der Dereferenzierung eines indirectly_readable Typs aufgerufen wird, ein predicate erfüllt (Konzept)
indirect_binary_predicate (C++20)	spezifiziert, dass ein aufrufbaren Typ, wenn er mit dem Ergebnis der Dereferenzierung zweier indirectly_readable Typen aufgerufen wird, ein predicate erfüllt (Konzept)
indirect_equivalence_relation (C++20)	spezifiziert, dass ein aufrufbaren Typ, wenn er mit dem Ergebnis der Dereferenzierung zweier indirectly_readable Typen aufgerufen wird, eine equivalence_relation erfüllt (Konzept)
indirect_strict_weak_order (C++20)	spezifiziert, dass ein aufrufbaren Typ, wenn er mit dem Ergebnis der Dereferenzierung zweier indirectly_readable Typen aufgerufen wird, eine strict_weak_order erfüllt (Konzept)
Gemeinsame Algorithmus-Anforderungen
indirectly_movable (C++20)	spezifiziert, dass Werte von einem indirectly_readable Typ zu einem indirectly_writable Typ verschoben werden können (Konzept)
indirectly_movable_storable (C++20)	spezifiziert, dass Werte von einem indirectly_readable Typ zu einem indirectly_writable Typ verschoben werden können und dass das Verschieben über ein Zwischenobjekt erfolgen kann (Konzept)
indirectly_copyable (C++20)	spezifiziert, dass Werte von einem indirectly_readable Typ zu einem indirectly_writable Typ kopiert werden können (Konzept)
indirectly_copyable_storable (C++20)	spezifiziert, dass Werte von einem indirectly_readable Typ zu einem indirectly_writable Typ kopiert werden können und dass das Kopieren über ein Zwischenobjekt erfolgen kann (Konzept)
indirectly_swappable (C++20)	spezifiziert, dass die Werte, auf die zwei indirectly_readable Typen verweisen, vertauscht werden können (Konzept)
indirectly_comparable (C++20)	spezifiziert, dass die Werte, auf die zwei indirectly_readable Typen verweisen, verglichen werden können (Konzept)
permutable (C++20)	spezifiziert die gemeinsamen Anforderungen für Algorithmen, die Elemente an Ort und Stelle neu ordnen (Konzept)
mergeable (C++20)	spezifiziert die Anforderungen für Algorithmen, die sortierte Sequenzen durch Kopieren von Elementen zu einer Ausgabesequenz zusammenführen (Konzept)
sortable (C++20)	spezifiziert die gemeinsamen Anforderungen für Algorithmen, die Sequenzen zu sortierten Sequenzen permutieren (Konzept)
Dienstprogramme
indirect_result_t (C++20)	berechnet das Ergebnis des Aufrufs eines aufrufbaren Objekts auf das Ergebnis der Dereferenzierung einer Menge von indirectly_readable Typen (Alias-Vorlage)
projected (C++20)	Hilfsvorlage zur Spezifizierung der Einschränkungen für Algorithmen, die Projektionen akzeptieren (Klassenvorlage)
projected_value_t (C++26)	berechnet den Werttyp eines indirectly_readable Typs mittels Projektion (Alias-Vorlage)

Iterator-Adapter

reverse_iterator	Iterator-Adapter für die Rückwärtsiteration (Klassenvorlage)
make_reverse_iterator (C++14)	erstellt einen std::reverse_iterator vom Typ, der aus dem Argument abgeleitet wird (Funktionsvorlage)
back_insert_iterator	Iterator-Adapter für die Einfügung am Ende eines Containers (Klassenvorlage)
back_inserter	erstellt einen std::back_insert_iterator vom Typ, der aus dem Argument abgeleitet wird (Funktionsvorlage)
front_insert_iterator	Iterator-Adapter für die Einfügung am Anfang eines Containers (Klassenvorlage)
front_inserter	erstellt einen std::front_insert_iterator vom Typ, der aus dem Argument abgeleitet wird (Funktionsvorlage)
insert_iterator	Iterator-Adapter für die Einfügung in einen Container (Klassenvorlage)
inserter	erstellt einen std::insert_iterator vom Typ, der aus dem Argument abgeleitet wird (Funktionsvorlage)
basic_const_iterator (C++23)	Iterator-Adapter, der einen Iterator in einen konstanten Iterator umwandelt (Klassenvorlage)
const_iterator (C++23)	berechnet einen konstanten Iteratortyp für einen gegebenen Typ (Alias-Vorlage)
const_sentinel (C++23)	berechnet einen Sentinel-Typ zur Verwendung mit konstanten Iteratoren (Alias-Vorlage)
make_const_iterator (C++23)	erstellt einen std::const_iterator vom Typ, der aus dem Argument abgeleitet wird (Funktionsvorlage)
make_const_sentinel (C++23)	erstellt einen std::const_sentinel vom Typ, der aus dem Argument abgeleitet wird (Funktionsvorlage)
move_iterator (C++11)	Iterator-Adapter, der zu einem rvalue dereferenziert (Klassenvorlage)
move_sentinel (C++20)	Sentinel-Adapter für std::move_iterator (Klassenvorlage)
make_move_iterator (C++11)	erstellt einen std::move_iterator vom Typ, der aus dem Argument abgeleitet wird (Funktionsvorlage)
common_iterator (C++20)	passt einen Iteratortyp und dessen Sentinel an einen gemeinsamen Iteratortyp an (Klassenvorlage)
default_sentinel_t (C++20)	Standard-Sentinel zur Verwendung mit Iteratoren, die die Grenze ihres Bereichs kennen (Klasse)
counted_iterator (C++20)	Iterator-Adapter, der den Abstand zum Ende des Bereichs verfolgt (Klassenvorlage)
unreachable_sentinel_t (C++20)	Sentinel, der immer ungleich zu jedem weakly_incrementable Typ ist (Klasse)

Stream-Iteratoren

istream_iterator	Eingabe-Iterator, der aus std::basic_istream liest (Klassenvorlage)
ostream_iterator	Ausgabe-Iterator, der in std::basic_ostream schreibt (Klassenvorlage)
istreambuf_iterator	Eingabe-Iterator, der aus std::basic_streambuf liest (Klassenvorlage)
ostreambuf_iterator	Ausgabe-Iterator, der in std::basic_streambuf schreibt (Klassenvorlage)

Iterator-Operationen

Definiert in Header <iterator>
advance	bewegt einen Iterator um die angegebene Distanz vorwärts (Funktionsvorlage)
distance	gibt die Distanz zwischen zwei Iteratoren zurück (Funktionsvorlage)
next (C++11)	inkrementiert einen Iterator (Funktionsvorlage)
prev (C++11)	dekrementiert einen Iterator (Funktionsvorlage)
ranges::advance (C++20)	bewegt einen Iterator um die angegebene Distanz vorwärts oder zu einer gegebenen Grenze (Algorithmus-Funktionsobjekt)
ranges::distance (C++20)	gibt die Distanz zwischen einem Iterator und einem Sentinel zurück oder die Distanz zwischen dem Anfang und dem Ende eines Bereichs (Algorithmus-Funktionsobjekt)
ranges::next (C++20)	inkrementiert einen Iterator um eine gegebene Distanz oder zu einer Grenze (Algorithmus-Funktionsobjekt)
ranges::prev (C++20)	dekrementiert einen Iterator um eine gegebene Distanz oder zu einer Grenze (Algorithmus-Funktionsobjekt)

Bereichszugriff (seit C++11)

Diese nicht-Member-Funktionsvorlagen bieten eine generische Schnittstelle für Container, einfache Arrays und std::initializer_list.

Definiert in der Header-Datei <array>
Definiert in Header <deque>
Definiert in Header <flat_map>
Definiert in Header <flat_set>
Definiert in Header <forward_list>
Definiert in Header <inplace_vector>
Definiert in Header <iterator>
Definiert in Header <list>
Definiert in Header <map>
Definiert in Header <regex>
Definiert in Header <set>
Definiert in Header <span>
Definiert in Header <string>
Definiert in Header <string_view>
Definiert in Header <unordered_map>
Definiert in Header <unordered_set>
Definiert in Header <vector>
Definiert im Namespace std
begincbegin (C++11)(C++14)	gibt einen Iterator zum Anfang eines Containers oder Arrays zurück (Funktionsvorlage)
endcend (C++11)(C++14)	gibt einen Iterator zum Ende eines Containers oder Arrays zurück (Funktionsvorlage)
rbegincrbegin (C++14)	gibt einen Reverse-Iterator zum Anfang eines Containers oder Arrays zurück (function template)
rendcrend (C++14)	gibt einen Reverse-End-Iterator für einen Container oder ein Array zurück (function template)
sizessize (C++17)(C++20)	gibt die Größe eines Containers oder Arrays zurück (Funktionsvorlage)
empty (C++17)	prüft, ob der Container leer ist (function template)
data (C++17)	erhält den Zeiger auf das zugrundeliegende Array (function template)

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
CWG 1181	C++98	Array-Typen konnten keine Wertetypen sein	sie können es
LWG 208	C++98	Iteratoren jenseits des Endes waren immer nicht-singulär	sie können singulär sein
LWG 278	C++98	die Gültigkeit eines Iterators war nicht definiert	als immer nicht-singulär definiert
LWG 324	C++98	Ausgabe-Iteratoren hatten Werttypen	Ausgabe-Iteratoren haben stattdessen schreibbare Typen
LWG 407	C++98	singuläre Iteratoren konnten nicht zerstört werden	erlaubt
LWG 408 (N3066)	C++98	singuläre Iteratoren konnten nicht kopiert werden	erlaubt, wenn sie wertinitialisiert sind
LWG 1185 (N3066)	C++98	LegacyForwardIterator, LegacyBidirectionalIterator und LegacyRandomAccessIterator erfüllen immer LegacyOutputIterator	sie erfüllen möglicherweise nicht LegacyOutputIterator
LWG 1210 (N3066)	C++98	die Definition von Iterator-Singularität und Erreichbarkeit hingen von Containern ab	hängen stattdessen von Sequenzen ab
LWG 3009	C++17	<string_view> stellte die Bereichszugriffs-Funktionsvorlagen nicht bereit	stellt diese Vorlagen bereit
LWG 3987	C++23	<flat_map> und <flat_set> taten dies nicht die Bereichszugriffs-Funktionsvorlagen bereitstellen	stellen diese Vorlagen bereit