Namespaces
Variants

Extensions for ranges

From cppreference.net
C++
Experimental
Ranges

Die C++-Erweiterungen für Ranges, ISO/IEC TS 21425:2017, spezifizieren eine Änderung an der Kernsprache und definieren neue Komponenten für die C++-Standardbibliothek, die auf dieser Seite aufgelistet sind.

Das Ranges TS basiert auf dem C++14-Standard, wie er durch das Concepts TS modifiziert wurde.

In ISO C++ integriert Die auf dieser Seite beschriebene Funktionalität wurde ab 10/2018 in den Hauptstandard von ISO C++ übernommen; siehe die Ranges-Bibliothek , die eingeschränkte Algorithmus-Bibliothek , und die Kernkonzepte-Bibliothek (seit C++20)

Inhaltsverzeichnis

Änderungen an der Kernsprache

Die Ranges TS modifiziert die Spezifikation von der bereichsbasierten for Schleife um unterschiedlich typisierte Begin- und End-Iteratoren zu erlauben. Diese Änderung ermöglicht die Verwendung von Sentinels und ist ebenfalls in C++17 vorhanden.

Konzepte

Kernsprachkonzepte
Definiert im Namespace std::experimental::ranges
spezifiziert, dass ein Typ derselbe wie ein anderer Typ ist
(Konzept)
spezifiziert, dass ein Typ von einem anderen Typ abgeleitet ist
(Konzept)
spezifiziert, dass ein Typ implizit in einen anderen Typ konvertierbar ist
(Konzept)
spezifiziert, dass zwei Typen einen gemeinsamen Referenztyp teilen
(Konzept)
spezifiziert, dass zwei Typen einen gemeinsamen Typ teilen
(Konzept)
gibt an, dass ein Typ ein integraler Typ ist
(Konzept)
spezifiziert, dass ein Typ ein vorzeichenbehafteter Ganzzahltyp ist
(Konzept)
spezifiziert, dass ein Typ ein integraler Typ ist, der nicht vorzeichenbehaftet ist
(Konzept)
gibt an, dass ein Typ von einem anderen Typ zuweisbar ist
(Konzept)
spezifiziert, dass ein Typ ausgetauscht werden kann oder dass zwei Typen miteinander ausgetauscht werden können
(Konzept)
Vergleichskonzepte
Definiert im Namespace std::experimental::ranges
gibt an, dass ein Typ in booleschen Kontexten verwendet werden kann
(Konzept)
spezifiziert, dass zwei Typen mit den Operatoren == und ! = auf Gleichheit verglichen werden können
(Konzept)
spezifiziert, dass der Operator == eine Äquivalenzrelation ist
(Konzept)
spezifiziert, dass die Vergleichsoperatoren des Typs eine Totalordnung ergeben
(Konzept)
Objektkonzepte
Definiert im Namespace std::experimental::ranges
spezifiziert, dass ein Objekt des Typs zerstört werden kann
(Konzept)
gibt an, dass eine Variable des Typs aus oder an einen Satz von Argumenttypen konstruiert oder gebunden werden kann
(Konzept)
gibt an, dass ein Objekt eines Typs standardmäßig konstruiert werden kann
(Konzept)
spezifiziert, dass ein Objekt eines Typs durch Move-Konstruktion erstellt werden kann
(Konzept)
spezifiziert, dass ein Objekt eines Typs kopierkonstruiert und bewegungskonstruiert werden kann
(Konzept)
spezifiziert, dass ein Objekt eines Typs verschoben und ausgetauscht werden kann
(Konzept)
spezifiziert, dass ein Objekt eines Typs kopiert, verschoben und ausgetauscht werden kann
(Konzept)
spezifiziert, dass ein Objekt eines Typs kopiert, verschoben, getauscht und standardkonstruiert werden kann
(Konzept)
spezifiziert, dass ein Typ regulär ist, das heißt, er ist sowohl Semiregular als auch EqualityComparable
(Konzept)
Callable-Konzepte
Definiert im Namespace std::experimental::ranges
spezifiziert, dass ein aufrufbarer Typ mit einem gegebenen Satz von Argumenttypen aufgerufen werden kann
(Konzept)
spezifiziert, dass ein aufrufbarer Typ ein boolesches Prädikat ist
(Konzept)
gibt an, dass ein aufrufbarer Typ eine binäre Relation ist
(Konzept)
spezifiziert, dass eine Relation eine strikte schwache Ordnung erzwingt
(Konzept)
Zufallszahlengenerator-Konzept
Definiert im Header <experimental/ranges/random>
Definiert im Namespace std::experimental::ranges
gibt an, dass ein Typ als gleichmäßiger Zufallszahlengenerator qualifiziert
(Konzept)

Allgemeine Hilfsmittel

Hilfskomponenten
Definiert im Namespace std::experimental::ranges
tauscht den Wert von zwei Objekten
(Anpassungspunktobjekt)
ersetzt das Argument durch einen neuen Wert und gibt seinen vorherigen Wert zurück
(Funktions-Template)
Funktionsobjekte
Definiert im Namespace std::experimental::ranges
ruft ein Callable Objekt mit den gegebenen Argumenten auf
(Funktions-Template)
Funktionsobjekt, das x == y implementiert
(Klassentemplate)
Funktionsobjekt, das x ! = y implementiert
(Klassentemplate)
Funktionsobjekt, das x > y implementiert
(Klassentemplate)
Funktionsobjekt, das x < y implementiert
(Klassentemplate)
Funktionsobjekt, das x >= y implementiert
(Klassentemplate)
Funktionsobjekt, das x <= y
(Klassentemplate)
Funktionsobjekt, das sein Argument unverändert zurückgibt
(Klasse)
Metaprogrammierung und Typmerkmale
Definiert im Namespace std::experimental::ranges
prüft, ob Objekte eines Typs mit Objekten desselben oder eines anderen Typs ausgetauscht werden können
(Klassentemplate)
Bestimmt den gemeinsamen Referenztyp einer Menge von Typen
(Klassentemplate)
Bestimmt den gemeinsamen Typ einer Menge von Typen
(Klassentemplate)
Markierte Paare und Tupel
Definiert im Namespace std::experimental::ranges
spezifiziert, dass ein Typ ein Tag-Spezifizierer ist
(Konzept)
spezifiziert, dass ein Typ einen Tag-Bezeichner und seinen Elementtyp repräsentiert
(Konzept)
erweitert einen tupelartigen Typ mit benannten Zugriffsfunktionen
(Klassentemplate)
Alias-Template für ein getaggtes std::pair
(Alias-Template)
Komfortfunktion zur Erstellung eines tagged_pair
(Funktionstemplate)
Definiert im Header <experimental/ranges/tuple>
Alias-Template für ein getaggtes std::tuple
(Alias-Template)
Komfortfunktion zur Erstellung eines tagged_tuple
(Funktions-Template)
Definiert im namespace std::experimental::ranges::tag
Tagspezifizierer zur Verwendung mit ranges::tagged
(Klasse)

Iteratoren

Iterator-bezogene Konzepte
Definiert im Namespace std::experimental::ranges
Iterator-Konzepte
spezifiziert, dass ein Typ durch Anwendung des Operators * lesbar ist
(Konzept)
spezifiziert, dass ein Wert in das referenzierte Objekt eines Iterators geschrieben werden kann
(Konzept)
spezifiziert, dass ein Semiregular Typ mit Prä- und Post-Inkrementoperatoren inkrementiert werden kann
(Konzept)
spezifiziert, dass die Inkrementoperation auf einem WeaklyIncrementable Typ gleichheitserhaltend ist und dass der Typ EqualityComparable ist
(Konzept)
gibt an, dass Objekte eines Typs inkrementiert und dereferenziert werden können
(Konzept)
spezifiziert, dass Objekte eines Typs ein Sentinel für einen Iterator Typ sind
(Konzept)
spezifiziert, dass der - Operator auf einen Iterator und einen Sentinel angewendet werden kann, um ihre Differenz in konstanter Zeit zu berechnen
(Konzept)
spezifiziert, dass ein Typ ein Eingabeiterator ist, das heißt, seine referenzierten Werte können gelesen werden und er kann sowohl prä- als auch postinkrementiert werden
(Konzept)
spezifiziert, dass ein Typ ein Ausgabeiterator für einen gegebenen Werttyp ist, das heißt, Werte dieses Typs können in ihn geschrieben werden und er kann sowohl prä- als auch post-inkrementiert werden
(Konzept)
spezifiziert, dass ein InputIterator ein Forward-Iterator ist, der Gleichheitsvergleiche und Multi-Pass unterstützt
(Konzept)
spezifiziert, dass ein ForwardIterator ein bidirektionaler Iterator ist, der Rückwärtsbewegung unterstützt
(Konzept)
spezifiziert, dass ein BidirectionalIterator ein Random-Access-Iterator ist, der Vorwärts- und Rückwärtsbewegung in konstanter Zeit und Indizierung unterstützt
(Konzept)
Indirekte Aufrufbare Konzepte
spezifiziert, dass ein aufrufbarer Typ mit dem Ergebnis der Dereferenzierung eines Readable Typs aufgerufen werden kann
(Konzept)
spezifiziert, dass ein aufrufbares Objekt, wenn es mit dem Ergebnis der Dereferenzierung eines Readable Typs aufgerufen wird, Predicate erfüllt
(Konzept)
spezifiziert, dass ein aufrufbares Objekt, wenn es mit dem Ergebnis der Dereferenzierung einiger Readable Typen aufgerufen wird, Relation erfüllt
(Konzept)
spezifiziert, dass ein aufrufbares Objekt, wenn es mit dem Ergebnis der Dereferenzierung einiger Readable Typen aufgerufen wird, StrictWeakOrder erfüllt
(Konzept)
Allgemeine Algorithmusanforderungen
spezifiziert, dass Werte von einem Readable Typ zu einem Writable Typ verschoben werden können
(Konzept)
spezifiziert, dass Werte von einem Readable Typ zu einem Writable Typ verschoben werden können und dass die Verschiebung über ein Zwischenobjekt erfolgen kann
(Konzept)
spezifiziert, dass Werte von einem Readable Typ zu einem Writable Typ kopiert werden können
(Konzept)
spezifiziert, dass Werte von einem Readable Typ zu einem Writable Typ kopiert werden können und dass die Kopie über ein Zwischenobjekt ausgeführt werden kann
(Konzept)
spezifiziert, dass die Werte, auf die von zwei Readable Typen referenziert wird, ausgetauscht werden können
(Konzept)
spezifiziert, dass die von zwei Readable Typen referenzierten Werte verglichen werden können
(Konzept)
spezifiziert die allgemeinen Anforderungen von Algorithmen, die Elemente direkt umordnen
(Konzept)
spezifiziert die Anforderungen von Algorithmen, die sortierte Sequenzen durch Kopieren von Elementen in eine Ausgabesequenz zusammenführen
(Konzept)
spezifiziert die allgemeinen Anforderungen von Algorithmen, die Sequenzen in geordnete Sequenzen umordnen
(Konzept)
Konzept-Hilfsmittel
Berechnet das Ergebnis des Aufrufs eines aufrufbaren Objekts auf das Ergebnis der Dereferenzierung einer Menge von Readable Typen
(Klassentemplate)
Hilfsvorlage zur Spezifikation der Constraints für Algorithmen, die Projektionen akzeptieren
(Klassentemplate)
Iterator-Primitive
Iterator-Utilities
Definiert im Namespace std::experimental::ranges
wandelt das Ergebnis der Dereferenzierung eines Objekts in seinen assoziierten Rvalue-Referenztyp um
(Anpassungspunktobjekt)
tauscht die Werte, auf die zwei dereferenzierbare Objekte verweisen
(Anpassungspunktobjekt)
Iterator-Eigenschaften
Definiert im Namespace std::experimental::ranges
ermittelt den Differenztyp eines WeaklyIncrementable Typs
(Klassentemplate)
ermittelt den Werttyp eines Readable Typs
(Klassentemplate)
ermittelt die Iterator-Kategorie eines Eingabe-Iterator-Typs
(Klassen-Template)
Kompatibilitäts-Merkmalsklasse, die die assoziierten Typen eines Iterators sammelt
(Alias-Template)
erhält die assoziierten Referenztypen eines dereferenzierbaren Objekts
(Alias-Template)
Iterator-Kategorie-Tags
Definiert im Namespace std::experimental::ranges
Leere Klassentypen, die zur Kennzeichnung von Iterator-Kategorien verwendet werden
(Klasse)
std::iterator_traits Spezialisierungen
Definiert im namespace std
spezialisiert std::iterator_traits für Ranges TS-Iteratoren
(Klassen-Template-Spezialisierung)
Iterator-Operationen
Definiert im Namespace std::experimental::ranges
bewegt einen Iterator um eine gegebene Distanz
(Funktions-Template)
gibt den Abstand zwischen einem Iterator und einem Sentinel oder zwischen dem Anfang und dem Ende eines Bereichs zurück
(Funktions-Template)
Inkrementiere einen Iterator
(Funktions-Template)
Dekrementiert einen Iterator
(Funktions-Template)
Iterator-Adapter
Definiert im namespace std::experimental::ranges
Iterator-Adapter für die Traversierung in umgekehrter Reihenfolge
(Klassentemplate)
Iterator-Adapter für das Einfügen am Ende eines Containers
(Klassentemplate)
Iterator-Adapter für das Einfügen am Anfang eines Containers
(Klassentemplate)
Iterator-Adapter für das Einfügen in einen Container
(Klassentemplate)
Iterator-Adapter, der eine Dereferenzierung zu einem Rvalue-Referenz durchführt
(Klassentemplate)
Sentinel-Adapter zur Verwendung mit move_iterator
(Klassentemplate)
passt ein Iterator-Sentinel-Paar an einen gemeinsamen Iteratortyp für die Verwendung mit Legacy-Algorithmen an
(Klassentemplate)
Iterator-Adapter, der den Abstand von seiner Startposition verfolgt
(Klassentemplate)
Leerer Sentinel-Typ zur Verwendung mit Iteratortypen, die die Grenze ihres Bereichs kennen
(Klasse)
Wrapper für einen möglicherweise hängenden Iterator
(Klassentemplate)
Alias-Template, das den Iteratortyp eines Rvalue-Ranges mit dangling umschließt
(Alias-Template)
Sentinel-Typ, der mit jedem Iterator verwendet wird, um einen unendlichen Bereich zu kennzeichnen
(Klasse)
Stream-Iteratoren
Definiert im Namespace std::experimental::ranges
Eingabe-Iterator, der aus std::basic_istream liest
(Klassentemplate)
Ausgabeiterator, der in std::basic_ostream schreibt
(Klassentemplate)
Eingabe-Iterator, der von std::basic_streambuf liest
(Klassentemplate)
Ausgabeiterator, der in std::basic_streambuf schreibt
(Klassentemplate)

Bereiche

Definiert im Header <experimental/ranges/range>
Range-Konzepte
spezifiziert, dass ein Typ ein Range ist, d.h. er stellt einen begin Iterator und einen end Sentinel bereit
(Konzept)
spezifiziert, dass ein Range seine Größe in konstanter Zeit kennt
(Konzept)
spezifiziert, dass ein Range eine View ist, d.h. er hat Kopieren/Verschieben/Zuweisen in konstanter Zeit
(Konzept)
spezifiziert, dass ein Range identische Iterator- und Sentinel-Typen hat
(Konzept)
spezifiziert einen Range, dessen Iterator-Typ InputIterator erfüllt
(Konzept)
spezifiziert einen Range, dessen Iterator-Typ OutputIterator erfüllt
(Konzept)
spezifiziert einen Range, dessen Iterator-Typ ForwardIterator erfüllt
(Konzept)
spezifiziert einen Range, dessen Iterator-Typ BidirectionalIterator erfüllt
(Konzept)
spezifiziert einen Range, dessen Iterator-Typ RandomAccessIterator erfüllt
(Konzept)
Range-Zugriff
Definiert im Namespace std::experimental::ranges
gibt einen Iterator zum Anfang eines Ranges zurück
(Customization Point Object)
gibt einen Iterator zum Ende eines Ranges zurück
(Customization Point Object)
gibt einen Reverse-Iterator zu einem Range zurück
(Customization Point Object)
gibt einen Reverse-End-Iterator zu einem Range zurück
(Customization Point Object)
Range-Primitive
Definiert im Namespace std::experimental::ranges
ermittelt die Größe eines Ranges, dessen Größe in konstanter Zeit berechnet werden kann
(Customization Point Object)
prüft, ob ein Range leer ist
(Customization Point Object)
ermittelt einen Zeiger zum Anfang eines zusammenhängenden Ranges
(Customization Point Object)
ermittelt die Iterator- und Sentinel-Typen eines Ranges
(Alias-Template)

Algorithmen

Nicht-modifizierende Sequenzoperationen
Definiert im Namespace std::experimental::ranges
prüft, ob ein Prädikat true für alle, irgendeine oder keine Elemente in einem Bereich ist
(Funktions-Template)
wendet eine Funktion auf einen Bereich von Elementen an
(Funktions-Template)
gibt die Anzahl der Elemente zurück, die bestimmte Kriterien erfüllen
(Funktions-Template)
findet die erste Position, an der zwei Bereiche sich unterscheiden
(Funktions-Template)
bestimmt, ob zwei Elementgruppen identisch sind
(Funktions-Template)
gibt true zurück, wenn ein Bereich lexikographisch kleiner als ein anderer ist
(Funktions-Template)
findet das erste Element, das bestimmte Kriterien erfüllt
(Funktions-Template)
findet die letzte Sequenz von Elementen in einem bestimmten Bereich
(Funktions-Template)
sucht nach einem beliebigen Element aus einer Menge von Elementen
(Funktions-Template)
findet die ersten zwei benachbarten Elemente, die gleich sind (oder ein gegebenes Prädikat erfüllen)
(Funktions-Template)
sucht nach einem Bereich von Elementen
(Funktions-Template)
sucht nach einer Anzahl aufeinanderfolgender Kopien eines Elements in einem Bereich
(Funktions-Template)
Modifizierende Sequenzoperationen
Definiert im Namespace std::experimental::ranges
kopiert eine Reihe von Elementen an einen neuen Speicherort
(Funktionsschablone)
kopiert eine Anzahl von Elementen an einen neuen Speicherort
(Funktionsschablone)
kopiert einen Elementbereich in umgekehrter Reihenfolge
(Funktions-Template)
verschiebt einen Bereich von Elementen an einen neuen Speicherort
(Funktionsschablone)
verschiebt einen Bereich von Elementen rückwärts an eine neue Position
(Funktionsschablone)
weist einer Reihe von Elementen einen bestimmten Wert zu
(Funktionsschablone)
weist einer Anzahl von Elementen einen Wert zu
(Funktions-Template)
wendet eine Funktion auf einen Elementbereich an
(Funktions-Template)
speichert das Ergebnis einer Funktion in einem Bereich
(Funktions-Template)
speichert das Ergebnis von N Aufrufen einer Funktion
(Funktions-Template)
entfernt Elemente, die bestimmten Kriterien entsprechen
(Funktionsschablone)
kopiert einen Bereich von Elementen unter Auslassung derjenigen, die bestimmte Kriterien erfüllen
(Funktions-Template)
ersetzt alle Werte, die bestimmte Kriterien erfüllen, durch einen anderen Wert
(Funktionsschablone)
kopiert einen Bereich und ersetzt Elemente, die bestimmte Kriterien erfüllen, durch einen anderen Wert
(Funktions-Template)
tauscht zwei Elementbereiche aus
(Funktionsschablone)
kehrt die Reihenfolge der Elemente in einem Bereich um
(Funktionsschablone)
erstellt eine Kopie eines Bereichs, der umgekehrt ist
(Funktions-Template)
dreht die Reihenfolge der Elemente in einem Bereich
(Funktionsschablone)
kopiert und rotiert eine Reihe von Elementen
(Funktionsschablone)
ordnet Elemente in einem Bereich zufällig neu an
(Funktionsschablone)
Entfernt aufeinanderfolgende doppelte Elemente in einem Bereich
(Funktionsschablone)
erstellt eine Kopie eines Elementbereichs, die keine aufeinanderfolgenden Duplikate enthält
(Funktionsschablone)
Partitionierungsoperationen
Definiert im namespace std::experimental::ranges
bestimmt, ob der Bereich durch das gegebene Prädikat partitioniert ist
(Funktionsschablone)
unterteilt eine Reihe von Elementen in zwei Gruppen
(Funktionsschablone)
kopiert einen Bereich und unterteilt die Elemente in zwei Gruppen
(Funktionsschablone)
teilt Elemente in zwei Gruppen, während ihre relative Reihenfolge erhalten bleibt
(Funktionsschablone)
ermittelt den Partitionierungspunkt eines partitionierten Bereichs
(Funktionsschablone)
Sortieroperationen
Definiert im namespace std::experimental::ranges
prüft, ob ein Bereich in aufsteigender Reihenfolge sortiert ist
(Funktionsschablone)
findet den größten sortierten Teilbereich
(Funktions-Template)
sortiert einen Bereich in aufsteigender Reihenfolge
(Funktions-Template)
sortiert die ersten N Elemente eines Bereichs
(Funktions-Template)
kopiert und teilweise sortiert einen Bereich von Elementen
(Funktions-Template)
sortiert eine Reihe von Elementen unter Beibehaltung der Reihenfolge zwischen gleichen Elementen
(Funktionsschablone)
sortiert den gegebenen Bereich teilweise und stellt sicher, dass er durch das gegebene Element partitioniert wird
(Funktionsschablone)
Binäre Suchoperationen (auf sortierten Bereichen)
Definiert im Namespace std::experimental::ranges
gibt einen Iterator zum ersten Element zurück, das nicht kleiner als der gegebene Wert ist
(Funktionsschablone)
gibt einen Iterator zum ersten Element zurück, das größer als ein bestimmter Wert ist
(Funktionsschablone)
bestimmt, ob ein Element in einem bestimmten Bereich existiert
(Funktionsschablone)
gibt den Bereich der Elemente zurück, die einem spezifischen Schlüssel entsprechen
(Funktionsschablone)
Mengenoperationen (auf sortierten Bereichen)
Definiert im Namespace std::experimental::ranges
verbindet zwei sortierte Bereiche
(Funktions-Template)
verbindet zwei geordnete Bereiche direkt
(Funktionsschablone)
gibt true zurück, falls eine Menge eine Teilmenge einer anderen ist
(Funktionsschablone)
berechnet die Differenz zwischen zwei Mengen
(Funktions-Template)
berechnet die Schnittmenge zweier Mengen
(Funktionsschablone)
berechnet die symmetrische Differenz zweier Mengen
(Funktionsschablone)
berechnet die Vereinigung zweier Mengen
(Funktionsschablone)
Heap-Operationen
Definiert im Namespace std::experimental::ranges
prüft, ob der gegebene Bereich einen Max-Heap darstellt
(Funktionsschablone)
findet den größten Teilbereich, der einen Max-Heap darstellt
(Funktions-Template)
erstellt einen Max-Heap aus einer Reihe von Elementen
(Funktions-Template)
fügt ein Element zu einem Max-Heap hinzu
(Funktions-Template)
entfernt das größte Element aus einem Max-Heap
(Funktions-Template)
wandelt einen Max-Heap in einen Bereich von Elementen um, die in aufsteigender Reihenfolge sortiert sind
(Funktionsschablone)
Minimum-/Maximum-Operationen
Definiert im Namespace std::experimental::ranges
gibt den größeren der gegebenen Werte zurück
(Funktions-Template)
gibt das größte Element in einem Bereich zurück
(Funktionsschablone)
gibt den kleineren der gegebenen Werte zurück
(Funktionsschablone)
gibt das kleinste Element in einem Bereich zurück
(Funktions-Template)
gibt das kleinere und größere von zwei Elementen zurück
(Funktionsschablone)
gibt die kleinsten und größten Elemente in einem Bereich zurück
(Funktionsschablone)
Permutationsoperationen
Definiert im Namespace std::experimental::ranges
bestimmt, ob eine Sequenz eine Permutation einer anderen Sequenz ist
(Funktions-Template)
erzeugt die nächstgrößere lexikografische Permutation eines Elementbereichs
(Funktionsschablone)
erzeugt die nächstkleinere lexikografische Permutation eines Elementbereichs
(Funktionsschablone)