Namespaces
Variants

    Algorithmenbibliothek

    Von de.cppreference.net
    < cpp
     
    C++
     
    Algorithmenbibliothek
    Eingeschränkte Algorithmen und Algorithmen auf Bereichen (C++20)
    Eingeschränkte Algorithmen, z. B. ranges::copy, ranges::sort, ...
    Nicht modifizierende Sequenzoperationen    
    Stapeloperationen
    (C++17)
    Suchoperationen
    Modifizierende Sequenzoperationen
    Kopieroperationen
    (C++11)
    (C++11)
    (C++11)
    Tauschoperationen
    Transformationsoperationen
    Generierungsoperationen
    Entfernungsoperationen
    Reihenfolgeändernde Operationen
    (bis C++17)(C++11)
    (C++20)(C++20)
    Stichprobenoperationen
    (C++17)

    Sortier- und verwandte Operationen
    Partitionierungsoperationen
    (C++11)    
    (C++11)

    Sortieroperationen
    Binäre Suchoperationen
    (auf partitionierten Bereichen)
    Mengenoperationen (auf sortierten Bereichen)
    Mischoperationen (auf sortierten Bereichen)
    Heap-Operationen
    Minimum/Maximum-Operationen
    (C++11)
    (C++17)
    Lexikografische Vergleichsoperationen
    (C++20)
    Permutationsoperationen


     

    Die Algorithmenbibliothek definiert Funktionen für verschiedene Zwecke (z.B. Suchen, Sortieren, Zählen, Manipulieren), die auf Bereiche von Elementen angewendet werden.

    Beschränkte Algorithmen (seit C++20)

    C++20 bietet beschränkte Versionen der meisten Algorithmen im Namensraum std::ranges. In diesen Algorithmen kann ein Bereich entweder als ein Iterator-Sentinel Paar oder als ein einzelnes Range Argument angegeben werden, und Projektionen und Zeiger-auf-Member-Aufrufbare werden unterstützt. Zusätzlich wurden die Rückgabetypen der meisten Algorithmen geändert, um alle potenziell nützlichen Informationen zurückzugeben, die während der Ausführung des Algorithmus berechnet wurden. 

    std::vector<int> v{7, 1, 4, 0, -1};
std::ranges::sort(v); // constrained algorithm

    Parallele Algorithmen (seit C++17)

    Ein paralleler Algorithmus ist ein Funktions-Template in der Algorithmenbibliothek mit einem Template-Parameter namens ExecutionPolicy oder durch execution-policy  eingeschränkt (seit C++26). Ein solcher Template-Parameter wird als Execution-Policy-Template-Parameter  bezeichnet, er beschreibt die Art und Weise, wie die Ausführung eines parallelen Algorithmus parallelisiert werden kann.

    Sofern nicht anders angegeben, dürfen parallele Algorithmen beliebige Kopien von Elementen aus Bereichen erstellen, solange sowohl std::is_trivially_copy_constructible_v<T> als auch std::is_trivially_destructible_v<T> true sind, wobei T der Typ der Elemente ist.

    Ausführungsstrategien

    Die Algorithmen der Standardbibliothek unterstützen mehrere Ausführungsstrategien, und die Bibliothek stellt entsprechende Ausführungsstrategietypen und -objekte bereit. Benutzer können eine Ausführungsstrategie statisch auswählen, indem sie einen parallelen Algorithmus mit einem Ausführungsstrategieobjekt des entsprechenden Typs aufrufen.

    Implementierungen der Standardbibliothek (aber nicht die Benutzer) können zusätzliche Ausführungsstrategien als Erweiterung definieren. Die Semantik paralleler Algorithmen, die mit einem Ausführungsstrategieobjekt eines implementationsdefinierten Typs aufgerufen werden, ist implementationsdefiniert.

    Definiert in Header <execution>
    Definiert im Namensraum std::execution
    (C++17)(C++17)(C++17)(C++20)
    		 Ausführungsstrategietypen
    (Klasse)
    (C++17)(C++17)(C++17)(C++20)
    		 globale Ausführungsstrategieobjekte
    (Konstante)
    Definiert im Namensraum std
    (C++17)
    		 prüft, ob eine Klasse eine Ausführungsstrategie darstellt
    (Klassentemplate)
    (C++26)
    		 gibt an, dass ein Typ eine Ausführungsstrategie darstellt
    (nur zur Veranschaulichung dienendes Konzept*)

    Nicht-modifizierende Sequenzoperationen

    Stapeloperationen

    Definiert in Header <algorithm>
    		wendet ein unäres Funktionsobjekt auf Elemente aus einem Bereich
    (Funktionstemplate & Algorithmus-Funktionsobjekt)
    (C++20)
    (C++17)
    		 wendet ein Funktionsobjekt auf die ersten N Elemente einer Sequenz an
    (Funktionstemplate & Algorithmus-Funktionsobjekt)
    (C++20)

    Suchoperationen

    Definiert in Header <algorithm>
    (C++11)(C++11)(C++11)
    		 prüft, ob ein Prädikat true für alle, eines oder keines der Elemente in einem Bereich
    (Funktionsschablone & Algorithmusfunktionsobjekt)
    (C++20)(C++20)(C++20)
    (C++23)(C++23)
    		 prüft, ob der Bereich das angegebene Element oder den angegebenen Unterbereich enthält
    (Algorithmusfunktionsobjekt)
    (C++11)
    		 findet das erste Element, das bestimmte Kriterien erfüllt
    (Funktionsschablone & Algorithmusfunktionsobjekt)
    (C++20)(C++20)(C++20)
    (C++23)(C++23)(C++23)
    		 findet das letzte Element, das bestimmte Kriterien erfüllt
    (Algorithmusfunktionsobjekt)
    		findet die letzte Folge von Elementen in einem bestimmten Bereich
    (Funktionsschablone & Algorithmusfunktionsobjekt)
    (C++20)
    		sucht nach einem beliebigen Element aus einer Menge von Elementen
    (Funktionsschablone & Algorithmusfunktionsobjekt)
    (C++20)
    		findet die ersten beiden benachbarten Elemente, die gleich sind (oder ein gegebenes Prädikat erfüllen)
    (Funktionsschablone & Algorithmusfunktionsobjekt)
    (C++20)
    		gibt die Anzahl der Elemente zurück, die bestimmte Kriterien erfüllen
    (Funktionsschablone & Algorithmusfunktionsobjekt)
    (C++20)(C++20)
    		findet die erste Position, an der sich zwei Bereiche unterscheiden
    (Funktionsschablone & Algorithmusfunktionsobjekt)
    (C++20)
    		bestimmt, ob zwei Mengen von Elementen gleich sind
    (Funktionsschablone & Algorithmusfunktionsobjekt)
    (C++20)
    		sucht nach dem ersten Vorkommen eines Bereichs von Elementen
    (Funktionsschablone & Algorithmusfunktionsobjekt)
    (C++20)
    		sucht nach dem ersten Vorkommen einer Anzahl aufeinanderfolgender Kopien eines Elements in einem Bereich
    (Funktionsschablone & Algorithmusfunktionsobjekt)
    (C++20)
    (C++23)
    		 prüft, ob ein Bereich mit einem anderen Bereich beginnt
    (Algorithmusfunktionsobjekt)
    (C++23)
    		 prüft, ob ein Bereich mit einem anderen Bereich endet
    (Algorithmusfunktionsobjekt)

    Falt-Operationen (seit C++23)

    Definiert in Header <algorithm>
    (C++23)
    		faltet eine Elementbereich von links
    (Algorithmus-Funktionsobjekt)
    (C++23)
    		faltet eine Elementbereich von links unter Verwendung des ersten Elements als Anfangswert
    (Algorithmus-Funktionsobjekt)
    (C++23)
    		faltet eine Elementbereich von rechts
    (Algorithmus-Funktionsobjekt)
    (C++23)
    		faltet eine Elementbereich von rechts unter Verwendung des letzten Elements als Anfangswert
    (Algorithmus-Funktionsobjekt)
    (C++23)
    		faltet eine Elementbereich von links und gibt ein Paar (Iterator, Wert) zurück
    (Algorithmus-Funktionsobjekt)
    (C++23)
    		faltet eine Elementbereich von links unter Verwendung des ersten Elements als Anfangswert und gibt ein Paar (Iterator, optional ) zurück
    (Algorithmus-Funktionsobjekt)

    Modifizierende Sequenzoperationen

    Kopieroperationen

    Definiert in Header <algorithm>
    (C++11)
    		 kopiert einen Bereich von Elementen an einen neuen Speicherort
    (Funktionsschablone & Algorithmus-Funktionsobjekt)
    (C++20)(C++20)
    (C++11)
    		 kopiert eine Anzahl von Elementen an einen neuen Speicherort
    (Funktionsschablone & Algorithmus-Funktionsobjekt)
    (C++20)
    		kopiert einen Bereich von Elementen in umgekehrter Reihenfolge
    (Funktionsschablone & Algorithmus-Funktionsobjekt)
    (C++20)
    (C++11)
    		 verschiebt einen Bereich von Elementen an einen neuen Speicherort
    (Funktionsschablone & Algorithmus-Funktionsobjekt)
    (C++20)
    (C++11)
    		 verschiebt einen Bereich von Elementen an einen neuen Speicherort in umgekehrter Reihenfolge
    (Funktionsschablone & Algorithmus-Funktionsobjekt)
    (C++20)

    Swap-Operationen

    Definiert in Header <algorithm>      (bis C++11)
    Definiert in Header <utility>          (seit C++11)
    Definiert in Header <string_view>
    		vertauscht die Werte zweier Objekte
    (Funktionsvorlage)
    Definiert in Header <algorithm>
    		vertauscht zwei Bereiche von Elementen
    (Funktionsvorlage & Algorithmus-Funktionsobjekt)
    (C++20)
    		vertauscht die Elemente, auf die zwei Iteratoren zeigen
    (Funktionsvorlage)

    Transformationsoperationen

    Definiert in Header <algorithm>
    		wendet eine Funktion auf einen Bereich von Elementen an und speichert die Ergebnisse in einem Zielbereich
    (Funktionsschablone & Algorithmus-Funktionsobjekt)
    (C++20)
    		ersetzt alle Werte, die bestimmte Kriterien erfüllen, durch einen anderen Wert
    (Funktionsschablone & Algorithmus-Funktionsobjekt)
    (C++20)(C++20)
    		kopiert einen Bereich und ersetzt Elemente, die bestimmte Kriterien erfüllen, durch einen anderen Wert
    (Funktionsschablone & Algorithmus-Funktionsobjekt)
    (C++20)(C++20)

    Generierungsoperationen

    Definiert in Header <algorithm>
    		weist jedem Element in einem Bereich den gegebenen Wert per Kopierzuweisung zu
    (Funktionstemplate & Algorithmus-Funktionsobjekt)
    (C++20)
    		weist N Elementen in einem Bereich den gegebenen Wert per Kopierzuweisung zu
    (Funktionstemplate & Algorithmus-Funktionsobjekt)
    (C++20)
    		weist jedem Element in einem Bereich die Ergebnisse aufeinanderfolgender Funktionsaufrufe zu
    (Funktionstemplate & Algorithmus-Funktionsobjekt)
    (C++20)
    		weist N Elementen in einem Bereich die Ergebnisse aufeinanderfolgender Funktionsaufrufe zu
    (Funktionstemplate & Algorithmus-Funktionsobjekt)
    (C++20)

    Entfernungsoperationen

    Definiert in Header <algorithm>
    		entfernt Elemente, die bestimmte Kriterien erfüllen
    (Funktionsschablone & Algorithmus-Funktionsobjekt)
    (C++20)(C++20)
    		kopiert einen Bereich von Elementen und lässt diejenigen aus, die bestimmte Kriterien erfüllen
    (Funktionsschablone & Algorithmus-Funktionsobjekt)
    (C++20)(C++20)
    		entfernt aufeinanderfolgende doppelte Elemente in einem Bereich
    (Funktionsschablone & Algorithmus-Funktionsobjekt)
    (C++20)
    		erstellt eine Kopie eines Bereichs von Elementen, die keine aufeinanderfolgenden Duplikate enthält
    (Funktionsschablone & Algorithmus-Funktionsobjekt)
    (C++20)

    Operationen zur Reihenfolgeänderung

    Definiert in Header <algorithm>
    		kehrt die Reihenfolge der Elemente in einem Bereich um
    (Funktionsschablone & Algorithmus-Funktionsobjekt)
    (C++20)
    		erstellt eine umgekehrte Kopie eines Bereichs
    (Funktionsschablone & Algorithmus-Funktionsobjekt)
    (C++20)
    		rotiert die Reihenfolge der Elemente in einem Bereich
    (Funktionsschablone & Algorithmus-Funktionsobjekt)
    (C++20)
    		kopiert und rotiert einen Bereich von Elementen
    (Funktionsschablone & Algorithmus-Funktionsobjekt)
    (C++20)
    (C++20)(C++20)
    		 verschiebt Elemente in einem Bereich
    (Funktionsschablone & Algorithmus-Funktionsobjekt)
    (C++23)(C++23)
    (bis C++17)(C++11)
    		 ordnet Elemente in einem Bereich zufällig neu
    (Funktionsschablone & Algorithmus-Funktionsobjekt)
    (C++20)

    Stichprobenoperationen

    Definiert in Header <algorithm>
    (C++17)
    		 wählt N zufällige Elemente aus einer Sequenz aus
    (Funktionstemplate & Algorithmus-Funktionsobjekt)
    (C++20)

    Sortieren und verwandte Operationen

    Anforderungen

    Manche Algorithmen setzen voraus, dass die durch die Argumente dargestellte Sequenz „sortiert“ oder „partitioniert“ ist. Das Verhalten ist undefiniert, wenn die Anforderung nicht erfüllt ist.

    Eine Sequenz istsortiert bezüglich eines Vergleichsoperatorscomp wenn für jeden Iteratoriter der auf die Sequenz zeigt und jede nicht-negative ganze Zahln so dassiter + n[1] ist ein gültiger Iterator der auf ein Element der Sequenz zeigt,comp(*(iter + n), *iter) == false[1].

    		(bis C++20)

    Eine Sequenz istsortiert bezüglichcomp undproj für einen Vergleichsoperatorcomp und eine Projektionproj wenn für jeden Iteratoriter der auf die Sequenz zeigt und jede nicht-negative ganze Zahln so dassiter + n[1] ein gültiger Iterator, der auf ein Element der Sequenz zeigt, bool(std::invoke(comp, std::invoke(proj, *(iter + n)),
                           std::invoke(proj, *iter)))     [1] ist false.

    Eine Sequenz istsortiert bezüglich eines Vergleichsoperatorscomp wenn die Sequenz sortiert ist bezüglichcomp undstd::identity{} (der Identitätsprojektion).

    		(seit C++20)

    Eine Sequenz[start, finish) istpartitioniert bezüglich eines Ausdrucksf(e) wenn es eine ganze Zahl gibtn so dass für allei in[0, std::distance(start, finish)), f(*(start + i))[1] isttrue genau dann, wenni < n.

    1. ↑ 1.0 1.1 1.2 1.3 1.4 iter + n bedeutet einfach „das Ergebnis voniter inkrementiert wirdn Mal“ ist, unabhängig davon, obiter ein Random-Access-Iterator ist.

    Partitionierungsoperationen

    Definiert in Header <algorithm>
    (C++11)
    		 bestimmt, ob der Bereich durch das gegebene Prädikat partitioniert ist
    (Funktionsschablone & Algorithmus-Funktionsobjekt)
    (C++20)
    		teilt einen Bereich von Elementen in zwei Gruppen auf
    (Funktionsschablone & Algorithmus-Funktionsobjekt)
    (C++20)
    (C++11)
    		 kopiert einen Bereich und teilt die Elemente in zwei Gruppen auf
    (Funktionsschablone & Algorithmus-Funktionsobjekt)
    (C++20)
    		teilt Elemente in zwei Gruppen auf, während ihre relative Reihenfolge innerhalb jeder Gruppe erhalten bleibt
    (Funktionsschablone & Algorithmus-Funktionsobjekt)
    (C++20)
    (C++11)
    		 lokalisiert den Partitionierungspunkt eines partitionierten Bereichs
    (Funktionsschablone & Algorithmus-Funktionsobjekt)
    (C++20)

    Sortieroperationen

    Definiert in Header <algorithm>
    		sortiert einen Bereich von Elementen
    (Funktionstemplate & Algorithmus-Funktionsobjekt)
    (C++20)
    		sortiert einen Bereich von Elementen, während die relative Reihenfolge zwischen gleichwertigen Elementen erhalten bleibt
    (Funktionstemplate & Algorithmus-Funktionsobjekt)
    (C++20)
    		sortiert die ersten N Elemente eines Bereichs
    (Funktionstemplate & Algorithmus-Funktionsobjekt)
    (C++20)
    		kopiert und sortiert teilweise einen Bereich von Elementen
    (Funktionstemplate & Algorithmus-Funktionsobjekt)
    (C++20)
    (C++11)
    		 prüft, ob ein Bereich sortiert ist
    (Funktionstemplate & Algorithmus-Funktionsobjekt)
    (C++20)
    (C++11)
    		 findet den größten sortierten Teilbereich
    (Funktionstemplate & Algorithmus-Funktionsobjekt)
    (C++20)
    		findet das N-te Element, wenn der Bereich sortiert wäre
    (Funktionstemplate & Algorithmus-Funktionsobjekt)
    (C++20)

    Binäre Suchoperationen (auf partitionierten Bereichen)

    Definiert in Header <algorithm>
    		findet das erste Element, das nicht kleiner als der gegebene Wert ist, mittels binärer Suche
    (Funktionsschablone & Algorithmus-Funktionsobjekt)
    (C++20)
    		findet das erste Element, das größer als der gegebene Wert ist, mittels binärer Suche
    (Funktionsschablone & Algorithmus-Funktionsobjekt)
    (C++20)
    		findet den Bereich von Elementen, die dem gegebenen Wert entsprechen, mittels binärer Suche
    (Funktionsschablone & Algorithmus-Funktionsobjekt)
    (C++20)
    		bestimmt, ob ein Element in einem Bereich vorhanden ist, mittels binärer Suche
    (Funktionsschablone & Algorithmus-Funktionsobjekt)
    (C++20)

    Mengenoperationen (auf sortierten Bereichen)

    Definiert in Header <algorithm>
    		bestimmt, ob eine Sequenz eine Teilsequenz einer anderen ist
    (Funktionstemplate & Algorithmus-Funktionsobjekt)
    (C++20)
    		berechnet die Vereinigung zweier Mengen
    (Funktionstemplate & Algorithmus-Funktionsobjekt)
    (C++20)
    		berechnet den Schnitt zweier Mengen
    (Funktionstemplate & Algorithmus-Funktionsobjekt)
    (C++20)
    		berechnet die Differenz zweier Mengen
    (Funktionstemplate & Algorithmus-Funktionsobjekt)
    (C++20)
    		berechnet die symmetrische Differenz zweier Mengen
    (Funktionstemplate & Algorithmus-Funktionsobjekt)
    (C++20)

    Merge-Operationen (auf sortierten Bereichen)

    Definiert in Header <algorithm>
    		führt zwei sortierte Bereiche zusammen
    (Funktionstemplate & Algorithmus-Funktionsobjekt)
    (C++20)
    		führt zwei geordnete Bereiche in-place zusammen
    (Funktionstemplate & Algorithmus-Funktionsobjekt)
    (C++20)

    Heap-Operationen

    Ein wahlfreier Zugriffsbereich range [first, last) ist ein Heap bezüglich eines Vergleichers comp wenn bool(comp(first[(i - 1) / 2], first[i])) false ist für alle ganzen Zahlen i in (0, last - first).

    		(bis C++20)

    Ein wahlfreier Zugriffsbereich range [first, last) ist ein Heap bezüglich comp und proj für einen Vergleicher comp und eine Projektion proj wenn bool(std::invoke(comp, std::invoke(proj, first[(i - 1) / 2]),
                           std::invoke(proj, first[i]))     false ist für alle ganzen Zahlen i in (0, last - first).

    Ein wahlfreier Zugriffsbereich [first, last) ist ein Heap bezüglich eines Vergleichers comp wenn der Bereich ein Heap bezüglich comp und std::identity{} ist (die Identitätsprojektion).

    		(seit C++20)

    Ein Heap kann durch std::make_heap und ranges::make_heap(seit C++20) erstellt werden.

    Für weitere Eigenschaften von Heaps siehe Max-Heap.


    Definiert in Header <algorithm>
    		fügt ein Element zu einem Max-Heap hinzu
    (Funktionsschablone & Algorithmus-Funktionsobjekt)
    (C++20)
    		entfernt das größte Element aus einem Max-Heap
    (Funktionsschablone & Algorithmus-Funktionsobjekt)
    (C++20)
    		erzeugt einen Max-Heap aus einem Bereich von Elementen
    (Funktionsschablone & Algorithmus-Funktionsobjekt)
    (C++20)
    		wandelt einen Max-Heap in einen Bereich von Elementen um, die in aufsteigender Reihenfolge sortiert sind
    (Funktionsschablone & Algorithmus-Funktionsobjekt)
    (C++20)
    (C++11)
    		 prüft, ob der angegebene Bereich ein Max-Heap ist
    (Funktionsschablone & Algorithmus-Funktionsobjekt)
    (C++20)
    (C++11)
    		 findet den größten Unterbereich, der ein Max-Heap ist
    (Funktionsschablone & Algorithmus-Funktionsobjekt)
    (C++20)

    Minimum-/Maximum-Operationen

    Definiert in Header<algorithm>
    		gibt den größeren der gegebenen Werte zurück
    (Funktionsschablone& Algorithmus-Funktionsobjekt)
    (C++20)
    		gibt das größte Element in einem Bereich zurück
    (Funktionsschablone& Algorithmus-Funktionsobjekt)
    (C++20)
    		gibt den kleineren der gegebenen Werte zurück
    (Funktionsschablone& Algorithmus-Funktionsobjekt)
    (C++20)
    		gibt das kleinste Element in einem Bereich zurück
    (Funktionsschablone& Algorithmus-Funktionsobjekt)
    (C++20)
    (C++11)
    		 gibt das kleinere und das größere von zwei Elementen zurück
    (Funktionsschablone& Algorithmus-Funktionsobjekt)
    (C++20)
    (C++11)
    		 gibt das kleinste und das größte Element in einem Bereich zurück
    (Funktionsschablone& Algorithmus-Funktionsobjekt)
    (C++20)
    (C++17)
    		 klemmt einen Wert zwischen ein Paar von Grenzwerten
    (Funktionsschablone& Algorithmus-Funktionsobjekt)
    (C++20)

    Lexikografische Vergleichsoperationen

    Definiert in Header <algorithm>
    		vergleicht zwei Bereiche lexikografisch
    (Funktionsschablone & Algorithmus-Funktionsobjekt)
    (C++20)
    (C++20)
    		 vergleicht zwei Bereiche mittels Dreiveg-Vergleich
    (Funktionsschablone)

    Permutationsoperationen

    Definiert in Header <algorithm>
    		erzeugt die nächstgrößere lexikografische Permutation eines Bereichs von Elementen
    (Funktionsschablone & Algorithmus-Funktionsobjekt)
    (C++20)
    		erzeugt die nächstkleinere lexikografische Permutation eines Bereichs von Elementen
    (Funktionsschablone & Algorithmus-Funktionsobjekt)
    (C++20)
    (C++11)
    		 bestimmt, ob eine Sequenz eine Permutation einer anderen Sequenz ist
    (Funktionsschablone & Algorithmus-Funktionsobjekt)
    (C++20)

    Numerische Operationen

    (C++11)
    		 füllt einen Bereich mit aufeinanderfolgenden Inkrementen des Startwerts
    (Funktionsschablone & Algorithmus-Funktionsobjekt)
    (C++23)
    		summiert oder faltet einen Bereich von Elementen
    (Funktionsschablone)
    		berechnet das innere Produkt zweier Elementbereiche
    (Funktionsschablone)
    		berechnet die Differenzen zwischen benachbarten Elementen in einem Bereich
    (Funktionsschablone)
    		berechnet die Partialsumme eines Elementbereichs
    (Funktionsschablone)
    (C++17)
    		 ähnlich wie std::accumulate, jedoch in beliebiger Reihenfolge
    (Funktionsschablone)
    (C++17)
    		 ähnlich wie std::partial_sum, schließt das ith Eingabeelement von der ith Summe aus
    (Funktionsschablone)
    (C++17)
    		 ähnlich wie std::partial_sum, schließt das ith Eingabeelement in die ith Summe ein
    (Funktionsschablone)
    (C++17)
    		 wendet ein aufrufbares Objekt an und reduziert dann in beliebiger Reihenfolge
    (Funktionsschablone)
    (C++17)
    		 wendet ein aufrufbares Objekt an und berechnet dann exklusiven Scan
    (Funktionsschablone)
    (C++17)
    		 wendet ein aufrufbares Objekt an und berechnet dann inklusiven Scan
    (Funktionsschablone)

    Spezialisierte <memory> Algorithmen

    Spezialisierte <random>Algorithmen (seit C++26)

    Definiert in Header <random>
    (C++26)
    		 füllt einen Bereich mit Zufallszahlen aus einem gleichmäßigen Zufallsbitgenerator
    (Algorithmus-Funktionsobjekt)

    Hinweise

    Feature-Test Makro Wert Std Feature
    __cpp_lib_algorithm_iterator_requirements 202207L (C++23) Ranges-Iteratoren als Eingaben für Nicht-Ranges-Algorithmen
    __cpp_lib_clamp 201603L (C++17) std::clamp
    __cpp_lib_constexpr_algorithms 201806L (C++20) Constexpr für Algorithmen
    202306L (C++26) Constexpr-Stable-Sortierung
    __cpp_lib_algorithm_default_value_type 202403L (C++26) Listeninitialisierung für Algorithmen
    __cpp_lib_freestanding_algorithm 202311L (C++26) Freestanding-Einrichtungen in <algorithm>
    __cpp_lib_robust_nonmodifying_seq_ops 201304L (C++14) Robuster machen nicht-modifizierender Sequenzoperationen (Zwei-Bereich-Überladungen für std::mismatch , std::equal und std::is_permutation)
    __cpp_lib_sample 201603L (C++17) std::sample
    __cpp_lib_shift 201806L (C++20) std::shift_left und std::shift_right

    C-Bibliothek

    Definiert im Header <cstdlib>
    		sortiert eine Reihe von Elementen mit unspezifiziertem Typ
    (Funktion)
    		durchsucht ein Array nach einem Element mit unspezifiziertem Typ
    (Funktion)

    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
    LWG 193 C++98 Heap erforderte * first als größtes Element Es können Elemente existieren
    gleich * first
    LWG 2150 C++98 Die Definition einer sortierten Sequenz war fehlerhaft korrigiert
    LWG 2166 C++98 Die Heap-Anforderung entsprach nicht eng genug
    der Definition von Max-Heap     		Anforderung verbessert

    Siehe auch

    C-Dokumentation für Algorithmen