Erweiterungen für Bereiche
Von cppreference.com
< cpp | experimental
Die C++ Extensions for Ranges, ISO/IEC TS 21425:2017, spezifiziert eine Modifikation der Kernsprache und definiert neue Komponenten für die C++-Standardbibliothek, die auf dieser Seite aufgeführt sind.
Die Ranges TS basiert auf dem C++14-Standard, modifiziert durch die Concepts TS.
[bearbeiten] Änderungen an der Kernsprache
Die Ranges TS modifiziert die Spezifikation der bereichsbasierten for-Schleife, um unterschiedlich typisierte Begin- und End-Iteratoren zuzulassen. Diese Änderung ermöglicht die Verwendung von Sentinels und ist auch in C++17 vorhanden.
[bearbeiten] Konzepte
Kernsprachen-Konzepte | |
| Definiert in Header
<experimental/ranges/concepts> | |
| Definiert im Namespace
std::experimental::ranges | |
| gibt an, dass ein Typ identisch mit einem anderen Typ ist (concept) | |
| gibt an, dass ein Typ von einem anderen Typ abgeleitet ist (concept) | |
| gibt an, dass ein Typ implizit in einen anderen Typ konvertierbar ist (concept) | |
| gibt an, dass zwei Typen einen gemeinsamen Referenztyp haben (concept) | |
| gibt an, dass zwei Typen einen gemeinsamen Typ haben (concept) | |
| gibt an, dass ein Typ ein ganzzahliger Typ ist (concept) | |
| gibt an, dass ein Typ ein vorzeichenbehafteter ganzzahliger Typ ist (concept) | |
| spezifiziert, dass ein Typ ein ganzzahliger Typ ist, der nicht vorzeichenbehaftet ist (concept) | |
| gibt an, dass ein Typ von einem anderen Typ zuweisbar ist (concept) | |
| gibt an, dass ein Typ vertauscht werden kann oder dass zwei Typen miteinander vertauscht werden können (concept) | |
Vergleichskonzepte | |
| Definiert in Header
<experimental/ranges/concepts> | |
| Definiert im Namespace
std::experimental::ranges | |
| gibt an, dass ein Typ in booleschen Kontexten verwendet werden kann (concept) | |
| spezifiziert, dass zwei Typen mit den Operatoren == und != auf Gleichheit verglichen werden können (concept) | |
| gibt an, dass der Operator == eine Äquivalenzrelation ist (concept) | |
| gibt an, dass die Vergleichsoperatoren des Typs eine Totalordnung ergeben (concept) | |
Objektkonzepte | |
| Definiert in Header
<experimental/ranges/concepts> | |
| Definiert im Namespace
std::experimental::ranges | |
| spezifiziert, dass ein Objekt des Typs zerstört werden kann (concept) | |
| gibt an, dass eine Variable des Typs aus einer Reihe von Argumenttypen konstruiert oder an sie gebunden werden kann (concept) | |
| gibt an, dass ein Objekt eines Typs standardkonstruiert werden kann (concept) | |
| gibt an, dass ein Objekt eines Typs per Move konstruiert werden kann (concept) | |
| gibt an, dass ein Objekt eines Typs kopierkonstruiert und per Move konstruiert werden kann (concept) | |
| gibt an, dass ein Objekt eines Typs verschoben und vertauscht werden kann (concept) | |
| gibt an, dass ein Objekt eines Typs kopiert, verschoben und vertauscht werden kann (concept) | |
| gibt an, dass ein Objekt eines Typs kopiert, verschoben, vertauscht und standardkonstruiert werden kann (concept) | |
spezifiziert, dass ein Typ regulär ist, d.h. er ist sowohl Semiregular als auch EqualityComparable(concept) | |
Aufrufbare Konzepte | |
| Definiert in Header
<experimental/ranges/concepts> | |
| Definiert im Namespace
std::experimental::ranges | |
| gibt an, dass ein aufrufbarer Typ mit einem gegebenen Satz von Argumenttypen aufgerufen werden kann (concept) | |
| gibt an, dass ein aufrufbarer Typ ein boolesches Prädikat ist (concept) | |
| gibt an, dass ein aufrufbarer Typ eine binäre Relation ist (concept) | |
spezifiziert, dass eine Relation eine strikte schwache Ordnung aufzwingt(concept) | |
Konzept für Zufallszahlengeneratoren | |
| Definiert in Header
<experimental/ranges/random> | |
| Definiert im Namespace
std::experimental::ranges | |
| spezifiziert, dass ein Typ als uniformer Zufallszahlengenerator qualifiziert ist (concept) | |
[bearbeiten] Allgemeine Dienstprogramme
Hilfskomponenten | |
| Definiert in Header
<experimental/ranges/utility> | |
| Definiert im Namespace
std::experimental::ranges | |
| tauscht den Wert zweier Objekte (customization point object) | |
| ersetzt das Argument durch einen neuen Wert und gibt seinen vorherigen Wert zurück (function template) | |
Funktionsobjekte | |
| Definiert in Header
<experimental/ranges/functional> | |
| Definiert im Namespace
std::experimental::ranges | |
| ruft ein Callable-Objekt mit den gegebenen Argumenten auf (function template) | |
| Funktions-Objekt, das x == y implementiert (class template) | |
| Funktions-Objekt, das x != y implementiert (class template) | |
| Funktions-Objekt, das x > y implementiert (class template) | |
| Funktions-Objekt, das x < y implementiert (class template) | |
| Funktions-Objekt, das x >= y implementiert (class template) | |
| Funktions-Objekt, das x <= y implementiert (class template) | |
| Funktions-Objekt, das sein Argument unverändert zurückgibt (class) | |
Metaprogrammierung und Typ-Traits | |
| Definiert in Header
<experimental/ranges/type_traits> | |
| Definiert im Namespace
std::experimental::ranges | |
| prüft, ob Objekte eines Typs mit Objekten desselben oder eines anderen Typs vertauscht werden können (class template) | |
| ermittelt den gemeinsamen Referenztyp einer Menge von Typen (class template) | |
| ermittelt den gemeinsamen Typ einer Menge von Typen (class template) | |
Getaggte Paare und Tupel | |
| Definiert in Header
<experimental/ranges/utility> | |
| Definiert im Namespace
std::experimental::ranges | |
| spezifiziert, dass ein Typ ein Tag-Specifier ist (concept) | |
| spezifiziert, dass ein Typ einen Tag-Specifier und seinen Elementtyp repräsentiert (concept) | |
| erweitert einen Tupel-ähnlichen Typ um benannte Accessoren (class template) | |
| Alias-Vorlage für ein getaggtes std::pair (alias template) | |
Komfortfunktion zum Erstellen eines tagged_pair(function template) | |
| Definiert in Header
<experimental/ranges/tuple> | |
| Alias-Vorlage für ein getaggtes std::tuple (alias template) | |
Komfortfunktion zum Erstellen eines tagged_tuple(function template) | |
| Definiert in Header
<experimental/ranges/algorithm> | |
| Definiert im Namespace
std::experimental::ranges::tag | |
| Tag-Specifier für die Verwendung mit ranges::tagged (class) | |
[bearbeiten] Iteratoren
| Definiert in Header
<experimental/ranges/iterator> | |
| | |
| Definiert im Namespace
std::experimental::ranges | |
Iterator-Konzepte | |
spezifiziert, dass ein Typ durch Anwenden des Operators * lesbar ist(concept) | |
| spezifiziert, dass ein Wert in das von einem Iterator referenzierte Objekt geschrieben werden kann (concept) | |
spezifiziert, dass ein Semiregular-Typ mit Prä- und Post-Inkrement-Operatoren inkrementiert werden kann(concept) | |
spezifiziert, dass die Inkrementoperation auf einem WeaklyIncrementable-Typ gleichheitserhaltend ist und dass der Typ EqualityComparable ist(concept) | |
| spezifiziert, dass Objekte eines Typs inkrementiert und dereferenziert werden können (concept) | |
spezifiziert, dass Objekte eines Typs ein Sentinel für einen Iterator-Typ sind(concept) | |
spezifiziert, dass der Operator - auf einen Iterator und ein Sentinel angewendet werden kann, um ihre Differenz in konstanter Zeit zu berechnen(concept) | |
| 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 (concept) | |
| 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 (concept) | |
spezifiziert, dass ein InputIterator ein Vorwärtsiterator ist, der Gleichheitsvergleich und Mehrfachdurchlauf unterstützt(concept) | |
spezifiziert, dass ein ForwardIterator ein bidirektionaler Iterator ist, der Rückwärtsbewegung unterstützt(concept) | |
spezifiziert, dass ein BidirectionalIterator ein Zufallszugriffsiterator ist, der Fortschritt in konstanter Zeit und Indizierung unterstützt(concept) | |
Indirekte aufrufbare Konzepte | |
spezifiziert, dass ein aufrufbarer Typ mit dem Ergebnis des Dereferenzierens eines Readable-Typs aufgerufen werden kann(concept) | |
spezifiziert, dass ein aufrufbares Objekt, wenn es mit dem Ergebnis des Dereferenzierens eines Readable-Typs aufgerufen wird, Predicate erfüllt(concept) | |
spezifiziert, dass ein aufrufbares Objekt, wenn es mit dem Ergebnis des Dereferenzierens einiger Readable-Typen aufgerufen wird, Relation erfüllt(concept) | |
spezifiziert, dass ein aufrufbares Objekt, wenn es mit dem Ergebnis des Dereferenzierens einiger Readable-Typen aufgerufen wird, StrictWeakOrder erfüllt(concept) | |
Gemeinsame Algorithmus-Anforderungen | |
spezifiziert, dass Werte von einem Readable-Typ zu einem Writable-Typ verschoben werden können(concept) | |
spezifiziert, dass Werte von einem Readable-Typ zu einem Writable-Typ verschoben werden können und dass das Verschieben über ein Zwischenobjekt erfolgen kann(concept) | |
spezifiziert, dass Werte von einem Readable-Typ zu einem Writable-Typ kopiert werden können(concept) | |
spezifiziert, dass Werte von einem Readable-Typ zu einem Writable-Typ kopiert werden können und dass das Kopieren über ein Zwischenobjekt erfolgen kann(concept) | |
spezifiziert, dass die Werte, auf die zwei Readable-Typen verweisen, vertauscht werden können(concept) | |
spezifiziert, dass die Werte, auf die zwei Readable-Typen verweisen, verglichen werden können(concept) | |
| spezifiziert die gemeinsamen Anforderungen für Algorithmen, die Elemente an Ort und Stelle neu ordnen (concept) | |
| spezifiziert die Anforderungen für Algorithmen, die sortierte Sequenzen durch Kopieren von Elementen zu einer Ausgabesequenz zusammenführen (concept) | |
| spezifiziert die gemeinsamen Anforderungen für Algorithmen, die Sequenzen zu sortierten Sequenzen permutieren (concept) | |
Konzept-Dienstprogramme | |
Berechnet das Ergebnis des Aufrufs eines aufrufbaren Objekts mit dem Ergebnis der Dereferenzierung einer Menge von Readable-Typen(Klassenvorlage) | |
| Hilfsvorlage zur Spezifizierung der Einschränkungen für Algorithmen, die Projektionen akzeptieren (Klassenvorlage) | |
Iterator-Primitive | |
Iterator-Dienstprogramme | |
| Definiert im Namespace
std::experimental::ranges | |
| wandelt das Ergebnis der Dereferenzierung eines Objekts in seinen zugehörigen rvalue-Referenztyp um (Anpassungspunkt-Objekt) | |
| tauscht die Werte, auf die zwei dereferenzierbare Objekte verweisen (Anpassungspunkt-Objekt) | |
Iterator-Traits | |
| Definiert im Namespace
std::experimental::ranges | |
erhält den Differenztyp eines WeaklyIncrementable-Typs(Klassenvorlage) | |
erhält den Werttyp eines Readable-Typs(Klassenvorlage) | |
| erhält die Iterator-Kategorie eines Eingabe-Iterator-Typs (Klassenvorlage) | |
| Kompatibilitäts-Traits-Klasse, die die zugehörigen Typen eines Iterators sammelt (Alias-Vorlage) | |
| erhält die assoziierten Referenztypen eines dereferenzierbaren Objekts (Alias-Vorlage) | |
Iterator-Kategorie-Tags | |
| Definiert im Namespace
std::experimental::ranges | |
| leere Klassentypen, die zur Angabe von Iterator-Kategorien verwendet werden (Klasse) | |
std::iterator_traits Spezialisierungen | |
| Definiert im Namespace
std | |
| spezialisiert std::iterator_traits für Ranges-TS-Iteratoren (Klassenvorlagen-Spezialisierung) | |
Iterator-Operationen | |
| Definiert im Namespace
std::experimental::ranges | |
| bewegt einen Iterator um die angegebene Distanz vorwärts (Funktionsvorlage) | |
| gibt die Distanz zwischen einem Iterator und einem Sentinel zurück, oder zwischen dem Anfang und dem Ende eines Bereichs (Funktionsvorlage) | |
| inkrementiert einen Iterator (Funktionsvorlage) | |
| dekrementiert einen Iterator (Funktionsvorlage) | |
Iterator-Adapter | |
| Definiert im Namespace
std::experimental::ranges | |
| Iterator-Adapter für die Rückwärtsiteration (Klassenvorlage) | |
| Iterator-Adapter für die Einfügung am Ende eines Containers (Klassenvorlage) | |
| Iterator-Adapter für die Einfügung am Anfang eines Containers (Klassenvorlage) | |
| Iterator-Adapter für die Einfügung in einen Container (Klassenvorlage) | |
| Iterator-Adapter, der zu einer rvalue-Referenz dereferenziert (Klassenvorlage) | |
Sentinel-Adapter zur Verwendung mit move_iterator(Klassenvorlage) | |
| passt ein Iterator-Sentinel-Paar an einen gemeinsamen Iteratortyp zur Verwendung mit Legacy-Algorithmen an (Klassenvorlage) | |
| Iterator-Adapter, der seine Distanz von seiner Startposition verfolgt (Klassenvorlage) | |
| leerer Sentinel-Typ zur Verwendung mit Iteratortypen, die die Grenze ihres Bereichs kennen (Klasse) | |
| Wrapper für einen möglicherweise ungültigen Iterator (Klassenvorlage) | |
Alias-Vorlage, die den Iteratortyp eines rvalue-Bereichs mit dangling umschließt(Alias-Vorlage) | |
| Sentinel-Typ, der mit jedem Iterator verwendet wird, um einen unendlichen Bereich zu bezeichnen (Klasse) | |
Stream-Iteratoren | |
| Definiert im Namespace
std::experimental::ranges | |
| Eingabe-Iterator, der aus std::basic_istream liest (Klassenvorlage) | |
| Ausgabe-Iterator, der in std::basic_ostream schreibt (Klassenvorlage) | |
| Eingabe-Iterator, der aus std::basic_streambuf liest (Klassenvorlage) | |
| Ausgabe-Iterator, der in std::basic_streambuf schreibt (Klassenvorlage) | |
[bearbeiten] Ranges
| Definiert in Header
<experimental/ranges/range> | |
Range-Konzepte | |
spezifiziert, dass ein Typ ein Range ist, d. h. er stellt einen begin-Iterator und ein end-Sentinel bereit(Konzept) | |
| spezifiziert, dass ein Range seine Größe in konstanter Zeit kennt (Konzept) | |
| spezifiziert, dass ein Range ein View ist, d. h. er hat konstante Zeit für Kopie/Verschiebung/Zuweisung (Konzept) | |
| spezifiziert, dass ein Range identische Iterator- und Sentinel-Typen hat (Konzept) | |
spezifiziert einen Bereich, dessen Iteratortyp InputIterator erfüllt(Konzept) | |
spezifiziert einen Bereich, dessen Iteratortyp OutputIterator erfüllt(Konzept) | |
spezifiziert einen Bereich, dessen Iteratortyp ForwardIterator erfüllt(Konzept) | |
spezifiziert einen Bereich, dessen Iteratortyp BidirectionalIterator erfüllt(Konzept) | |
spezifiziert einen Bereich, dessen Iteratortyp RandomAccessIterator erfüllt(Konzept) | |
Bereichszugriff | |
| Definiert im Namespace
std::experimental::ranges | |
| gibt einen Iterator zum Anfang eines Ranges zurück (Anpassungspunkt-Objekt) | |
| gibt einen Iterator zum Ende eines Bereichs zurück (Anpassungspunkt-Objekt) | |
| gibt einen Reverse-Iterator zu einem Range zurück (Anpassungspunkt-Objekt) | |
| gibt einen Reverse-End-Iterator zu einem Range zurück (Anpassungspunkt-Objekt) | |
Range-Primitive | |
| Definiert im Namespace
std::experimental::ranges | |
| erhält die Größe eines Bereichs, dessen Größe in konstanter Zeit berechnet werden kann (Anpassungspunkt-Objekt) | |
| prüft, ob ein Range leer ist (Anpassungspunkt-Objekt) | |
| ruft einen Zeiger auf den Anfang eines zusammenhängenden Ranges ab (Anpassungspunkt-Objekt) | |
| erhält die Iterator- und Sentinel-Typen eines Bereichs (Alias-Vorlage) | |
[bearbeiten] Algorithmen
| Definiert in Header
<experimental/ranges/algorithm> | |
Nicht-modifizierende Sequenzoperationen | |
| Definiert im Namespace
std::experimental::ranges | |
| Prüft, ob eine Bedingung für alle, einige oder keine Elemente in einem Bereich wahr ist (Funktionsvorlage) | |
| Wendet eine Funktion auf einen Elementbereich an (Funktionsvorlage) | |
| Gibt die Anzahl der Elemente zurück, die bestimmte Kriterien erfüllen (Funktionsvorlage) | |
| Findet die erste Position, an der sich zwei Bereiche unterscheiden (Funktionsvorlage) | |
| Bestimmt, ob zwei Elementmengen gleich sind (Funktionsvorlage) | |
| gibt true zurück, wenn ein Bereich lexikographisch kleiner als ein anderer ist (Funktionsvorlage) | |
| Findet das erste Element, das bestimmte Kriterien erfüllt (Funktionsvorlage) | |
| Findet die letzte Sequenz von Elementen in einem bestimmten Bereich (Funktionsvorlage) | |
| Sucht nach einem der Elemente aus einer Menge von Elementen (Funktionsvorlage) | |
| Findet die ersten beiden benachbarten Elemente, die gleich sind (oder eine gegebene Bedingung erfüllen) (Funktionsvorlage) | |
| sucht nach einem Bereich von Elementen (Funktionsvorlage) | |
| sucht nach einer Anzahl aufeinanderfolgender Kopien eines Elements in einem Bereich (Funktionsvorlage) | |
Modifizierende Sequenzoperationen | |
| Definiert im Namespace
std::experimental::ranges | |
| Kopiert einen Elementbereich an einen neuen Speicherort (Funktionsvorlage) | |
| Kopiert eine Anzahl von Elementen an einen neuen Speicherort (Funktionsvorlage) | |
| Kopiert einen Elementbereich in umgekehrter Reihenfolge (Funktionsvorlage) | |
| Verschiebt einen Elementbereich an einen neuen Speicherort (Funktionsvorlage) | |
| Verschiebt einen Elementbereich in umgekehrter Reihenfolge an einen neuen Speicherort (Funktionsvorlage) | |
| Weist einem Elementbereich einen bestimmten Wert zu (Funktionsvorlage) | |
| Weist einer Anzahl von Elementen einen Wert zu (Funktionsvorlage) | |
| Wendet eine Funktion auf einen Elementbereich an (Funktionsvorlage) | |
| Speichert das Ergebnis einer Funktion in einem Bereich (Funktionsvorlage) | |
| Speichert das Ergebnis von N Funktionsanwendungen (Funktionsvorlage) | |
| entfernt Elemente, die bestimmte Kriterien erfüllen (Funktionsvorlage) | |
| Kopiert einen Bereich von Elementen und lässt diejenigen aus, die bestimmte Kriterien erfüllen (Funktionsvorlage) | |
| Ersetzt alle Werte, die bestimmte Kriterien erfüllen, durch einen anderen Wert (Funktionsvorlage) | |
| Kopiert einen Bereich und ersetzt Elemente, die bestimmte Kriterien erfüllen, durch einen anderen Wert (Funktionsvorlage) | |
| Tauscht zwei Elementbereiche (Funktionsvorlage) | |
| Kehrt die Reihenfolge der Elemente in einem Bereich um (Funktionsvorlage) | |
| Erstellt eine Kopie eines Bereichs, der umgekehrt ist (Funktionsvorlage) | |
| Rotiert die Reihenfolge der Elemente in einem Bereich (Funktionsvorlage) | |
| Kopiert und rotiert einen Bereich von Elementen (Funktionsvorlage) | |
| Ordnet Elemente in einem Bereich zufällig neu an (Funktionsvorlage) | |
| Entfernt aufeinanderfolgende doppelte Elemente in einem Bereich (Funktionsvorlage) | |
| Erstellt eine Kopie eines Bereichs von Elementen, die keine aufeinanderfolgenden Duplikate enthält (Funktionsvorlage) | |
Partitionierungsoperationen | |
| Definiert im Namespace
std::experimental::ranges | |
| Stellt fest, ob der Bereich durch das gegebene Prädikat partitioniert ist (Funktionsvorlage) | |
| Teilt einen Bereich von Elementen in zwei Gruppen auf (Funktionsvorlage) | |
| Kopiert einen Bereich und teilt die Elemente in zwei Gruppen auf (Funktionsvorlage) | |
| Teilt Elemente in zwei Gruppen auf und behält dabei ihre relative Reihenfolge bei (Funktionsvorlage) | |
| Findet den Partitionierungspunkt eines partitionierten Bereichs (Funktionsvorlage) | |
Sortieroperationen | |
| Definiert im Namespace
std::experimental::ranges | |
| Prüft, ob ein Bereich aufsteigend sortiert ist (Funktionsvorlage) | |
| Findet den größten sortierten Teilbereich (Funktionsvorlage) | |
| Sortiert einen Bereich aufsteigend (Funktionsvorlage) | |
| Sortiert die ersten N Elemente eines Bereichs (Funktionsvorlage) | |
| Kopiert und sortiert einen Bereich von Elementen teilweise (Funktionsvorlage) | |
| Sortiert einen Bereich von Elementen und behält dabei die Reihenfolge zwischen gleichen Elementen bei (Funktionsvorlage) | |
| Sortiert den gegebenen Bereich teilweise, so dass er durch das gegebene Element partitioniert wird (Funktionsvorlage) | |
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 (Funktionsvorlage) | |
| Gibt einen Iterator zum ersten Element zurück, das *größer* als ein bestimmter Wert ist (Funktionsvorlage) | |
| bestimmt, ob ein Element in einem bestimmten Bereich existiert (Funktionsvorlage) | |
| gibt den Bereich von Elementen zurück, die einem bestimmten Schlüssel entsprechen (Funktionsvorlage) | |
Mengenoperationen (auf sortierten Bereichen) | |
| Definiert im Namespace
std::experimental::ranges | |
| Führt zwei sortierte Bereiche zusammen (Funktionsvorlage) | |
| Führt zwei sortierte Bereiche an Ort und Stelle zusammen (Funktionsvorlage) | |
| gibt true zurück, wenn eine Menge eine Teilmenge einer anderen ist (Funktionsvorlage) | |
| Berechnet die Differenz zwischen zwei Mengen (Funktionsvorlage) | |
| Berechnet den Schnitt zweier Mengen (Funktionsvorlage) | |
| Berechnet die symmetrische Differenz zwischen zwei Mengen (Funktionsvorlage) | |
| Berechnet die Vereinigung zweier Mengen (Funktionsvorlage) | |
Heapoperationen | |
| Definiert im Namespace
std::experimental::ranges | |
| Prüft, ob der gegebene Bereich ein Max-Heap ist (Funktionsvorlage) | |
| Findet den größten Teilbereich, der ein Max-Heap ist (Funktionsvorlage) | |
| Erstellt aus einem Bereich von Elementen einen Max-Heap (Funktionsvorlage) | |
| Fügt ein Element zu einem Max-Heap hinzu (Funktionsvorlage) | |
| Entfernt das größte Element aus einem Max-Heap (Funktionsvorlage) | |
| Verwandelt einen Max-Heap in einen aufsteigend sortierten Bereich von Elementen (Funktionsvorlage) | |
Minimum/Maximum-Operationen | |
| Definiert im Namespace
std::experimental::ranges | |
| Gibt den größeren der beiden Werte zurück (Funktionsvorlage) | |
| Gibt das größte Element in einem Bereich zurück (Funktionsvorlage) | |
| Gibt den kleineren der beiden Werte zurück (Funktionsvorlage) | |
| gibt das kleinste Element in einem Bereich zurück (Funktionsvorlage) | |
| gibt die kleinere und größere von zwei Elementen zurück (Funktionsvorlage) | |
| gibt das kleinste und das größte Element in einem Bereich zurück (Funktionsvorlage) | |
Permutationsoperationen | |
| Definiert im Namespace
std::experimental::ranges | |
| bestimmt, ob eine Sequenz eine Permutation einer anderen Sequenz ist (Funktionsvorlage) | |
| erzeugt die nächstgrößere lexikographische Permutation eines Bereichs von Elementen (Funktionsvorlage) | |
| erzeugt die nächstkleinere lexikographische Permutation eines Bereichs von Elementen (Funktionsvorlage) | |
