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

 

Algorithmenbibliothek

Beschränkte Algorithmen und Algorithmen für Bereiche (C++20)
Beschränkte Algorithmen, z.B. ranges::copy, ranges::sort, ...
Ausführungsrichtlinien (C++17)
is_execution_policy (C++17)   execution::seqexecution::parexecution::par_unseqexecution::unseq (C++17)    (C++17)(C++17)(C++20)	execution::sequenced_policyexecution::parallel_policyexecution::parallel_unsequenced_policyexecution::parallel_unsequenced (C++17)(C++17)(C++17)(C++20)
Nicht-modifizierende Sequenzoperationen Stapeloperationen for_each for_each_n (C++17) Suchoperationen all_ofany_ofnone_of (C++11)                (C++11)(C++11) countcount_if mismatch equal findfind_iffind_if_not (C++11) find_end find_first_of adjacent_find search search_n Modifizierende Sequenzoperationen Kopieroperationen copycopy_if (C++11) copy_backward copy_n (C++11) move (C++11) move_backward (C++11) Tauschoperationen swap iter_swap swap_ranges Transformationsoperationen replacereplace_if transform replace_copyreplace_copy_if Generierungsoperationen fill fill_n generate generate_n Entfernungsoperationen removeremove_if unique remove_copyremove_copy_if unique_copy Ordnungsändernde Operationen reverse reverse_copy rotate rotate_copy random_shuffleshuffle (bis C++17)(C++11) shift_leftshift_right (C++20)(C++20) Stichprobenoperationen sample (C++17)	Sortier- und verwandte Operationen Partitionierungsoperationen partition partition_copy (C++11)   stable_partition is_partitioned (C++11) partition_point (C++11) Sortieroperationen sort stable_sort partial_sort partial_sort_copy is_sorted (C++11) is_sorted_until (C++11) nth_element Binäre Suchoperationen (auf partitionierten Bereichen) lower_bound upper_bound equal_range binary_search Mengenoperationen (auf sortierten Bereichen) includes set_union set_intersection set_difference set_symmetric_difference Zusammenführungsoperationen (auf sortierten Bereichen) merge inplace_merge Heapoperationen push_heap pop_heap make_heap sort_heap is_heap (C++11) is_heap_until (C++11) Minimum/Maximum-Operationen max min minmax (C++11) clamp (C++17) max_element min_element minmax_element (C++11) Lexikographische Vergleichsoperationen lexicographical_compare lexicographical_compare_three_way (C++20) Permutationsoperationen next_permutation prev_permutation is_permutation (C++11) C-Bibliothek qsort bsearch
Numerische Operationen
iota (C++11) inner_product adjacent_difference    accumulate reduce (C++17) transform_reduce (C++17)	partial_sum inclusive_scan (C++17)    exclusive_scan (C++17) transform_inclusive_scan (C++17) transform_exclusive_scan (C++17)
Operationen auf uninitialisiertem Speicher
uninitialized_copy uninitialized_move (C++17)    uninitialized_fill uninitialized_copy_n (C++11) uninitialized_move_n (C++17) uninitialized_fill_n	destroy (C++17) destroy_n (C++17) destroy_at (C++17) construct_at (C++20)       uninitialized_default_construct (C++17) uninitialized_value_construct (C++17) uninitialized_default_construct_n (C++17) uninitialized_value_construct_n (C++17)

 

Die Algorithmenbibliothek definiert Funktionen für eine Vielzahl von Zwecken (z. B. Suchen, Sortieren, Zählen, Manipulieren), die auf Elementbereichen operieren. Beachten Sie, dass ein Bereich definiert ist als [first, last), wobei sich last auf das Element *nach* dem letzten zu inspizierenden oder zu modifizierenden Element bezieht.

Eingeschränkte Algorithmen (seit C++20)

C++20 bietet eingeschränkte Versionen der meisten Algorithmen im Namespace std::ranges. In diesen Algorithmen kann ein Bereich entweder als ein Iterator-Sentinelsystem-Paar oder als ein einzelnes Bereichs-Argument angegeben werden, und Projektionen sowie Zeiger-auf-Mitglied-Aufrufe 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

Ausführungsrichtlinien (seit C++17)

Die meisten Algorithmen haben Überladungen, die Ausführungsrichtlinien akzeptieren. Die Standardbibliotheksalgorithmen unterstützen mehrere Ausführungsrichtlinien, und die Bibliothek stellt entsprechende Ausführungsrichtlinientypen und -objekte bereit. Benutzer können eine Ausführungsrichtlinie statisch auswählen, indem sie einen parallelen Algorithmus mit einem Ausführungsrichtlinienobjekt des entsprechenden Typs aufrufen.

Implementierungen der Standardbibliothek (aber nicht die Benutzer) können zusätzliche Ausführungsrichtlinien als Erweiterung definieren. Die Semantik von parallelen Algorithmen, die mit einem Ausführungsrichtlinienobjekt eines implementierungsdefinierten Typs aufgerufen werden, ist implementierungsdefiniert.

Parallele Versionen von Algorithmen (mit Ausnahme von std::for_each und std::for_each_n) dürfen 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.

Definiert in Header <execution>
Definiert im Namensraum std::execution
sequenced_policyparallel_policyparallel_unsequenced_policyunsequenced_policy (C++17)(C++17)(C++17)(C++20)	Ausführungsrichtlinientypen (Klasse)
seqparpar_unsequnseq (C++17)(C++17)(C++17)(C++20)	Globale Ausführungsrichtlinienobjekte (Konstante)
Definiert im Namespace std
is_execution_policy (C++17)	Prüft, ob eine Klasse eine Ausführungsrichtlinie darstellt (Klassentemplate)

Feature-Test-Makro	Wert	Std	Feature
__cpp_lib_parallel_algorithm	201603L	(C++17)	Parallele Algorithmen
__cpp_lib_execution	201603L	(C++17)	Ausführungsrichtlinien
	201902L	(C++20)	std::execution::unsequenced_policy

Nicht-modifizierende Sequenzoperationen

Stapeloperationen

Definiert in Header <algorithm>
for_each	wendet ein unäres Funktionsobjekt auf Elemente aus einem Bereich an (Funktion-Template)
ranges::for_each (C++20)	wendet ein unäres Funktionsobjekt auf Elemente aus einem Bereich an (Algorithmus-Funktionsobjekt)
for_each_n (C++17)	Wendet ein Funktionsobjekt auf die ersten N Elemente einer Sequenz an (Funktionstempelat)
ranges::for_each_n (C++20)	Wendet ein Funktionsobjekt auf die ersten N Elemente einer Sequenz an (Algorithmus-Funktionsobjekt)

Suchoperationen

Definiert in Header <algorithm>
all_ofany_ofnone_of (C++11)(C++11)(C++11)	Prüft, ob eine Bedingung für alle, einige oder keine Elemente in einem Bereich wahr ist (Funktionstempelat)
ranges::all_ofranges::any_ofranges::none_of (C++20)(C++20)(C++20)	Prüft, ob eine Bedingung für alle, einige oder keine Elemente in einem Bereich wahr ist (Algorithmus-Funktionsobjekt)
ranges::containsranges::contains_subrange (C++23)(C++23)	Prüft, ob der Bereich das gegebene Element oder den gegebenen Teilbereich enthält (Algorithmus-Funktionsobjekt)
findfind_iffind_if_not (C++11)	Findet das erste Element, das bestimmte Kriterien erfüllt (Funktionstempelat)
ranges::findranges::find_ifranges::find_if_not (C++20)(C++20)(C++20)	Findet das erste Element, das bestimmte Kriterien erfüllt (Algorithmus-Funktionsobjekt)
ranges::find_lastranges::find_last_ifranges::find_last_if_not (C++23)(C++23)(C++23)	Findet das letzte Element, das bestimmte Kriterien erfüllt (Algorithmus-Funktionsobjekt)
find_end	Findet die letzte Sequenz von Elementen in einem bestimmten Bereich (Funktionstempelat)
ranges::find_end (C++20)	Findet die letzte Sequenz von Elementen in einem bestimmten Bereich (Algorithmus-Funktionsobjekt)
find_first_of	Sucht nach einem der Elemente aus einer Menge von Elementen (Funktionstempelat)
ranges::find_first_of (C++20)	Sucht nach einem der Elemente aus einer Menge von Elementen (Algorithmus-Funktionsobjekt)
adjacent_find	Findet die ersten beiden benachbarten Elemente, die gleich sind (oder eine gegebene Bedingung erfüllen) (Funktionstempelat)
ranges::adjacent_find (C++20)	Findet die ersten beiden benachbarten Elemente, die gleich sind (oder eine gegebene Bedingung erfüllen) (Algorithmus-Funktionsobjekt)
countcount_if	Gibt die Anzahl der Elemente zurück, die bestimmte Kriterien erfüllen (Funktionstempelat)
ranges::countranges::count_if (C++20)(C++20)	Gibt die Anzahl der Elemente zurück, die bestimmte Kriterien erfüllen (Algorithmus-Funktionsobjekt)
mismatch	Findet die erste Position, an der sich zwei Bereiche unterscheiden (Funktionstempelat)
ranges::mismatch (C++20)	Findet die erste Position, an der sich zwei Bereiche unterscheiden (Algorithmus-Funktionsobjekt)
equal	Bestimmt, ob zwei Elementmengen gleich sind (Funktionstempelat)
ranges::equal (C++20)	Bestimmt, ob zwei Elementmengen gleich sind (Algorithmus-Funktionsobjekt)
search	Sucht nach dem ersten Vorkommen eines Elementbereichs (Funktionstempelat)
ranges::search (C++20)	Sucht nach dem ersten Vorkommen eines Elementbereichs (Algorithmus-Funktionsobjekt)
search_n	Sucht nach dem ersten Vorkommen einer Anzahl aufeinanderfolgender Kopien eines Elements in einem Bereich (Funktionstempelat)
ranges::search_n (C++20)	Sucht nach dem ersten Vorkommen einer Anzahl aufeinanderfolgender Kopien eines Elements in einem Bereich (Algorithmus-Funktionsobjekt)
ranges::starts_with (C++23)	Prüft, ob ein Bereich mit einem anderen Bereich beginnt (Algorithmus-Funktionsobjekt)
ranges::ends_with (C++23)	Prüft, ob ein Bereich mit einem anderen Bereich endet (Algorithmus-Funktionsobjekt)

Faltoperationen (seit C++23)

Definiert in Header <algorithm>
ranges::fold_left (C++23)	Faltet einen Elementbereich von links (Algorithmus-Funktionsobjekt)
ranges::fold_left_first (C++23)	Faltet einen Elementbereich von links unter Verwendung des ersten Elements als Anfangswert (Algorithmus-Funktionsobjekt)
ranges::fold_right (C++23)	Faltet einen Elementbereich von rechts (Algorithmus-Funktionsobjekt)
ranges::fold_right_last (C++23)	Faltet einen Elementbereich von rechts unter Verwendung des letzten Elements als Anfangswert (Algorithmus-Funktionsobjekt)
ranges::fold_left_with_iter (C++23)	Faltet einen Elementbereich von links und gibt ein Paar (Iterator, Wert) zurück (Algorithmus-Funktionsobjekt)
ranges::fold_left_first_with_iter (C++23)	Faltet einen 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>
copycopy_if (C++11)	Kopiert einen Elementbereich an einen neuen Speicherort (Funktionstempelat)
ranges::copyranges::copy_if (C++20)(C++20)	Kopiert einen Elementbereich an einen neuen Speicherort (Algorithmus-Funktionsobjekt)
copy_n (C++11)	Kopiert eine Anzahl von Elementen an einen neuen Speicherort (Funktionstempelat)
ranges::copy_n (C++20)	Kopiert eine Anzahl von Elementen an einen neuen Speicherort (Algorithmus-Funktionsobjekt)
copy_backward	Kopiert einen Elementbereich in umgekehrter Reihenfolge (Funktionstempelat)
ranges::copy_backward (C++20)	Kopiert einen Elementbereich in umgekehrter Reihenfolge (Algorithmus-Funktionsobjekt)
move (C++11)	Verschiebt einen Elementbereich an einen neuen Speicherort (Funktionstempelat)
ranges::move (C++20)	Verschiebt einen Elementbereich an einen neuen Speicherort (Algorithmus-Funktionsobjekt)
move_backward (C++11)	Verschiebt einen Elementbereich in umgekehrter Reihenfolge an einen neuen Speicherort (Funktionstempelat)
ranges::move_backward (C++20)	Verschiebt einen Elementbereich in umgekehrter Reihenfolge an einen neuen Speicherort (Algorithmus-Funktionsobjekt)

Tauschoperationen

Definiert in Header <algorithm>   (bis C++11)
Definiert in Header <utility>     (seit C++11)
Definiert in Header <string_view>
swap	tauscht die Werte von zwei Objekten (Funktionsvorlage)
Definiert in Header <algorithm>
swap_ranges	Tauscht zwei Elementbereiche (Funktionstempelat)
ranges::swap_ranges (C++20)	Tauscht zwei Elementbereiche (Algorithmus-Funktionsobjekt)
iter_swap	Tauscht die Elemente, auf die zwei Iteratoren zeigen (Funktionstempelat)

Transformationsoperationen

Definiert in Header <algorithm>
transform	Wendet eine Funktion auf einen Elementbereich an und speichert die Ergebnisse in einem Zielbereich (Funktionstempelat)
ranges::transform (C++20)	Wendet eine Funktion auf einen Elementbereich an (Algorithmus-Funktionsobjekt)
replacereplace_if	Ersetzt alle Werte, die bestimmte Kriterien erfüllen, durch einen anderen Wert (Funktionstempelat)
ranges::replaceranges::replace_if (C++20)(C++20)	Ersetzt alle Werte, die bestimmte Kriterien erfüllen, durch einen anderen Wert (Algorithmus-Funktionsobjekt)
replace_copyreplace_copy_if	Kopiert einen Bereich und ersetzt Elemente, die bestimmte Kriterien erfüllen, durch einen anderen Wert (Funktionstempelat)
ranges::replace_copyranges::replace_copy_if (C++20)(C++20)	Kopiert einen Bereich und ersetzt Elemente, die bestimmte Kriterien erfüllen, durch einen anderen Wert (Algorithmus-Funktionsobjekt)

Generierungsoperationen

Definiert in Header <algorithm>
fill	Weist jedem Element in einem Bereich den gegebenen Wert zu (Funktionstempelat)
ranges::fill (C++20)	Weist einem Elementbereich einen bestimmten Wert zu (Algorithmus-Funktionsobjekt)
fill_n	Weist N Elementen in einem Bereich den gegebenen Wert zu (Funktionstempelat)
ranges::fill_n (C++20)	Weist einer Anzahl von Elementen einen Wert zu (Algorithmus-Funktionsobjekt)
generate	Weist die Ergebnisse aufeinanderfolgender Funktionsaufrufe jedem Element in einem Bereich zu (Funktionstempelat)
ranges::generate (C++20)	Speichert das Ergebnis einer Funktion in einem Bereich (Algorithmus-Funktionsobjekt)
generate_n	Weist die Ergebnisse aufeinanderfolgender Funktionsaufrufe N Elementen in einem Bereich zu (Funktionstempelat)
ranges::generate_n (C++20)	Speichert das Ergebnis von N Funktionsanwendungen (Algorithmus-Funktionsobjekt)

Entfernungsoperationen

Definiert in Header <algorithm>
removeremove_if	entfernt Elemente, die bestimmte Kriterien erfüllen (Funktionstemplate)
ranges::removeranges::remove_if (C++20)(C++20)	entfernt Elemente, die bestimmte Kriterien erfüllen (Algorithmus-Funktionsobjekt)
remove_copyremove_copy_if	Kopiert einen Bereich von Elementen und lässt diejenigen aus, die bestimmte Kriterien erfüllen (Funktionstemplate)
ranges::remove_copyranges::remove_copy_if (C++20)(C++20)	Kopiert einen Bereich von Elementen und lässt diejenigen aus, die bestimmte Kriterien erfüllen (Algorithmus-Funktionsobjekt)
unique	Entfernt aufeinanderfolgende doppelte Elemente in einem Bereich (Funktionstemplate)
ranges::unique (C++20)	Entfernt aufeinanderfolgende doppelte Elemente in einem Bereich (Algorithmus-Funktionsobjekt)
unique_copy	Erstellt eine Kopie eines Bereichs von Elementen, die keine aufeinanderfolgenden Duplikate enthält (Funktionstemplate)
ranges::unique_copy (C++20)	Erstellt eine Kopie eines Bereichs von Elementen, die keine aufeinanderfolgenden Duplikate enthält (Algorithmus-Funktionsobjekt)

Ordnungsändernde Operationen

Definiert in Header <algorithm>
reverse	Kehrt die Reihenfolge der Elemente in einem Bereich um (Funktionstemplate)
ranges::reverse (C++20)	Kehrt die Reihenfolge der Elemente in einem Bereich um (Algorithmus-Funktionsobjekt)
reverse_copy	Erstellt eine Kopie eines Bereichs, der umgekehrt ist (Funktionstemplate)
ranges::reverse_copy (C++20)	Erstellt eine Kopie eines Bereichs, der umgekehrt ist (Algorithmus-Funktionsobjekt)
rotate	Rotiert die Reihenfolge der Elemente in einem Bereich (Funktionstemplate)
ranges::rotate (C++20)	Rotiert die Reihenfolge der Elemente in einem Bereich (Algorithmus-Funktionsobjekt)
rotate_copy	Kopiert und rotiert einen Bereich von Elementen (Funktionstemplate)
ranges::rotate_copy (C++20)	Kopiert und rotiert einen Bereich von Elementen (Algorithmus-Funktionsobjekt)
shift_leftshift_right (C++20)	Verschiebt Elemente in einem Bereich (Funktionstemplate)
ranges::shift_leftranges::shift_right (C++23)	Verschiebt Elemente in einem Bereich (Algorithmus-Funktionsobjekt)
random_shuffleshuffle (bis C++17)(C++11)	Ordnet Elemente in einem Bereich zufällig neu an (Funktionstemplate)
ranges::shuffle (C++20)	Ordnet Elemente in einem Bereich zufällig neu an (Algorithmus-Funktionsobjekt)

Stichprobenoperationen

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

Sortier- und verwandte Operationen

Anforderungen

Einige Algorithmen erfordern, dass die durch die Argumente repräsentierte Sequenz „sortiert“ oder „partitioniert“ ist. Das Verhalten ist undefiniert, wenn die Anforderung nicht erfüllt ist.

Eine Sequenz ist bezüglich eines Komparators comp sortiert, wenn für jeden Iterator iter, der auf die Sequenz zeigt, und jede nicht-negative ganze Zahl n, so dass iter + n ein gültiger Iterator ist, der auf ein Element der Sequenz zeigt, gilt comp(*(iter + n), *iter) == false.

(bis C++20)

Eine Sequenz ist bezüglich comp und proj für einen Komparator comp und eine Projektion proj sortiert, wenn für jeden Iterator iter, der auf die Sequenz zeigt, und jede nicht-negative ganze Zahl n, so dass iter + n ein gültiger Iterator ist, der auf ein Element der Sequenz zeigt, bool(std::invoke(comp, std::invoke(proj, *(iter + n)),                        std::invoke(proj, *iter))) false ist. Eine Sequenz ist bezüglich eines Komparators comp sortiert, wenn die Sequenz bezüglich comp und std::identity{} (der Identitätsprojektion) sortiert ist.

(seit C++20)

Eine Sequenz [start, finish) ist bezüglich eines Ausdrucks f(e) partitioniert, wenn es eine ganze Zahl n gibt, so dass für alle i in [​0​, std::distance(start, finish)) gilt f(*(start + i)) genau dann true ist, wenn i < n.

Partitionierungsoperationen

Definiert in Header <algorithm>
is_partitioned (C++11)	Stellt fest, ob der Bereich durch das gegebene Prädikat partitioniert ist (Funktionstemplate)
ranges::is_partitioned (C++20)	Stellt fest, ob der Bereich durch das gegebene Prädikat partitioniert ist (Algorithmus-Funktionsobjekt)
partition	Teilt einen Bereich von Elementen in zwei Gruppen auf (Funktionstemplate)
ranges::partition (C++20)	Teilt einen Bereich von Elementen in zwei Gruppen auf (Algorithmus-Funktionsobjekt)
partition_copy (C++11)	Kopiert einen Bereich und teilt die Elemente in zwei Gruppen auf (Funktionstemplate)
ranges::partition_copy (C++20)	Kopiert einen Bereich und teilt die Elemente in zwei Gruppen auf (Algorithmus-Funktionsobjekt)
stable_partition	Teilt Elemente in zwei Gruppen auf und behält dabei ihre relative Reihenfolge bei (Funktionstemplate)
ranges::stable_partition (C++20)	Teilt Elemente in zwei Gruppen auf und behält dabei ihre relative Reihenfolge bei (Algorithmus-Funktionsobjekt)
partition_point (C++11)	Findet den Partitionierungspunkt eines partitionierten Bereichs (Funktionstemplate)
ranges::partition_point (C++20)	Findet den Partitionierungspunkt eines partitionierten Bereichs (Algorithmus-Funktionsobjekt)

Sortieroperationen

Definiert in Header <algorithm>
sort	Sortiert einen Bereich aufsteigend (Funktionstemplate)
ranges::sort (C++20)	Sortiert einen Bereich aufsteigend (Algorithmus-Funktionsobjekt)
stable_sort	Sortiert einen Bereich von Elementen und behält dabei die Reihenfolge zwischen gleichen Elementen bei (Funktionstemplate)
ranges::stable_sort (C++20)	Sortiert einen Bereich von Elementen und behält dabei die Reihenfolge zwischen gleichen Elementen bei (Algorithmus-Funktionsobjekt)
partial_sort	Sortiert die ersten N Elemente eines Bereichs (Funktionstemplate)
ranges::partial_sort (C++20)	Sortiert die ersten N Elemente eines Bereichs (Algorithmus-Funktionsobjekt)
partial_sort_copy	Kopiert und sortiert einen Bereich von Elementen teilweise (Funktionstemplate)
ranges::partial_sort_copy (C++20)	Kopiert und sortiert einen Bereich von Elementen teilweise (Algorithmus-Funktionsobjekt)
is_sorted (C++11)	Prüft, ob ein Bereich aufsteigend sortiert ist (Funktionstemplate)
ranges::is_sorted (C++20)	Prüft, ob ein Bereich aufsteigend sortiert ist (Algorithmus-Funktionsobjekt)
is_sorted_until (C++11)	Findet den größten sortierten Teilbereich (Funktionstemplate)
ranges::is_sorted_until (C++20)	Findet den größten sortierten Teilbereich (Algorithmus-Funktionsobjekt)
nth_element	Sortiert den gegebenen Bereich teilweise, so dass er durch das gegebene Element partitioniert wird (Funktionstemplate)
ranges::nth_element (C++20)	Sortiert den gegebenen Bereich teilweise, so dass er durch das gegebene Element partitioniert wird (Algorithmus-Funktionsobjekt)

Binäre Suchoperationen (auf partitionierten Bereichen)

Definiert in Header <algorithm>
lower_bound	Gibt einen Iterator zum ersten Element zurück, das nicht kleiner als der gegebene Wert ist (Funktionstemplate)
ranges::lower_bound (C++20)	Gibt einen Iterator zum ersten Element zurück, das nicht kleiner als der gegebene Wert ist (Algorithmus-Funktionsobjekt)
upper_bound	Gibt einen Iterator zum ersten Element zurück, das *größer* als ein bestimmter Wert ist (Funktionstemplate)
ranges::upper_bound (C++20)	Gibt einen Iterator zum ersten Element zurück, das *größer* als ein bestimmter Wert ist (Algorithmus-Funktionsobjekt)
equal_range	gibt den Bereich von Elementen zurück, die einem bestimmten Schlüssel entsprechen (Funktionstemplate)
ranges::equal_range (C++20)	gibt den Bereich von Elementen zurück, die einem bestimmten Schlüssel entsprechen (Algorithmus-Funktionsobjekt)
binary_search	Stellt fest, ob ein Element in einem teilweise geordneten Bereich vorhanden ist (Funktionstemplate)
ranges::binary_search (C++20)	Stellt fest, ob ein Element in einem teilweise geordneten Bereich vorhanden ist (Algorithmus-Funktionsobjekt)

Mengenoperationen (auf sortierten Bereichen)

Definiert in Header <algorithm>
includes	Gibt true zurück, wenn eine Sequenz eine Untersequenz einer anderen ist (Funktionstemplate)
ranges::includes (C++20)	Gibt true zurück, wenn eine Sequenz eine Untersequenz einer anderen ist (Algorithmus-Funktionsobjekt)
set_union	Berechnet die Vereinigung zweier Mengen (Funktionstemplate)
ranges::set_union (C++20)	Berechnet die Vereinigung zweier Mengen (Algorithmus-Funktionsobjekt)
set_intersection	Berechnet den Schnitt zweier Mengen (Funktionstemplate)
ranges::set_intersection (C++20)	Berechnet den Schnitt zweier Mengen (Algorithmus-Funktionsobjekt)
set_difference	Berechnet die Differenz zwischen zwei Mengen (Funktionstemplate)
ranges::set_difference (C++20)	Berechnet die Differenz zwischen zwei Mengen (Algorithmus-Funktionsobjekt)
set_symmetric_difference	Berechnet die symmetrische Differenz zwischen zwei Mengen (Funktionstemplate)
ranges::set_symmetric_difference (C++20)	Berechnet die symmetrische Differenz zwischen zwei Mengen (Algorithmus-Funktionsobjekt)

Zusammenführungsoperationen (auf sortierten Bereichen)

Definiert in Header <algorithm>
merge	Führt zwei sortierte Bereiche zusammen (Funktionstemplate)
ranges::merge (C++20)	Führt zwei sortierte Bereiche zusammen (Algorithmus-Funktionsobjekt)
inplace_merge	Führt zwei sortierte Bereiche an Ort und Stelle zusammen (Funktionstemplate)
ranges::inplace_merge (C++20)	Führt zwei sortierte Bereiche an Ort und Stelle zusammen (Algorithmus-Funktionsobjekt)

Heap-Operationen

Ein Zufallszugriffs-Bereich [first, last) ist ein Heap bezüglich eines Komparators comp, wenn bool(comp(first[(i - 1) / 2], first[i])) für jede ganze Zahl i in (​0​, last - first) false ist.

(bis C++20)

Ein Zufallszugriffs-Bereich [first, last) ist ein Heap bezüglich comp und proj für einen Komparator comp und eine Projektion proj, wenn bool(std::invoke(comp, std::invoke(proj, first[(i - 1) / 2]),                        std::invoke(proj, first[i])) für jede ganze Zahl i in (​0​, last - first) false ist. Ein Zufallszugriffs-Bereich [first, last) ist ein Heap bezüglich eines Komparators comp, wenn der Bereich bezüglich comp und std::identity{} (der Identitätsprojektion) ein Heap ist.

(seit C++20)

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

Weitere Eigenschaften von Heaps finden Sie unter Max Heap.

Definiert in Header <algorithm>
push_heap	Fügt ein Element zu einem Max-Heap hinzu (Funktionstemplate)
ranges::push_heap (C++20)	Fügt ein Element zu einem Max-Heap hinzu (Algorithmus-Funktionsobjekt)
pop_heap	Entfernt das größte Element aus einem Max-Heap (Funktionstemplate)
ranges::pop_heap (C++20)	Entfernt das größte Element aus einem Max-Heap (Algorithmus-Funktionsobjekt)
make_heap	Erstellt aus einem Bereich von Elementen einen Max-Heap (Funktionstemplate)
ranges::make_heap (C++20)	Erstellt aus einem Bereich von Elementen einen Max-Heap (Algorithmus-Funktionsobjekt)
sort_heap	Verwandelt einen Max-Heap in einen aufsteigend sortierten Bereich von Elementen (Funktionstemplate)
ranges::sort_heap (C++20)	Verwandelt einen Max-Heap in einen aufsteigend sortierten Bereich von Elementen (Algorithmus-Funktionsobjekt)
is_heap (C++11)	Prüft, ob der gegebene Bereich ein Max-Heap ist (Funktionstemplate)
ranges::is_heap (C++20)	Prüft, ob der gegebene Bereich ein Max-Heap ist (Algorithmus-Funktionsobjekt)
is_heap_until (C++11)	Findet den größten Teilbereich, der ein Max-Heap ist (Funktionstemplate)
ranges::is_heap_until (C++20)	Findet den größten Teilbereich, der ein Max-Heap ist (Algorithmus-Funktionsobjekt)

Minimum-/Maximumoperationen

Definiert in Header <algorithm>
max	Gibt den größeren der beiden Werte zurück (Funktionstemplate)
ranges::max (C++20)	Gibt den größeren der beiden Werte zurück (Algorithmus-Funktionsobjekt)
max_element	Gibt das größte Element in einem Bereich zurück (Funktionstemplate)
ranges::max_element (C++20)	Gibt das größte Element in einem Bereich zurück (Algorithmus-Funktionsobjekt)
min	Gibt den kleineren der beiden Werte zurück (Funktionstemplate)
ranges::min (C++20)	Gibt den kleineren der beiden Werte zurück (Algorithmus-Funktionsobjekt)
min_element	gibt das kleinste Element in einem Bereich zurück (Funktionsvorlage)
ranges::min_element (C++20)	gibt das kleinste Element in einem Bereich zurück (Algorithmus-Funktionsobjekt)
minmax (C++11)	gibt die kleinere und größere von zwei Elementen zurück (Funktionsvorlage)
ranges::minmax (C++20)	gibt die kleinere und größere von zwei Elementen zurück (Algorithmus-Funktionsobjekt)
minmax_element (C++11)	gibt das kleinste und das größte Element in einem Bereich zurück (Funktionsvorlage)
ranges::minmax_element (C++20)	gibt das kleinste und das größte Element in einem Bereich zurück (Algorithmus-Funktionsobjekt)
clamp (C++17)	klemmt einen Wert zwischen einem Paar von Grenzwerte (Funktionsvorlage)
ranges::clamp (C++20)	klemmt einen Wert zwischen einem Paar von Grenzwerte (Algorithmus-Funktionsobjekt)

Lexikographische Vergleichsoperationen

Definiert in Header <algorithm>
lexicographical_compare	gibt true zurück, wenn ein Bereich lexikographisch kleiner als ein anderer ist (Funktionsvorlage)
ranges::lexicographical_compare (C++20)	gibt true zurück, wenn ein Bereich lexikographisch kleiner als ein anderer ist (Algorithmus-Funktionsobjekt)
lexicographical_compare_three_way (C++20)	vergleicht zwei Bereiche mittels Drei-Wege-Vergleich (Funktionsvorlage)

Permutationsoperationen

Definiert in Header <algorithm>
next_permutation	erzeugt die nächstgrößere lexikographische Permutation eines Bereichs von Elementen (Funktionsvorlage)
ranges::next_permutation (C++20)	erzeugt die nächstgrößere lexikographische Permutation eines Bereichs von Elementen (Algorithmus-Funktionsobjekt)
prev_permutation	erzeugt die nächstkleinere lexikographische Permutation eines Bereichs von Elementen (Funktionsvorlage)
ranges::prev_permutation (C++20)	erzeugt die nächstkleinere lexikographische Permutation eines Bereichs von Elementen (Algorithmus-Funktionsobjekt)
is_permutation (C++11)	bestimmt, ob eine Sequenz eine Permutation einer anderen Sequenz ist (Funktionsvorlage)
ranges::is_permutation (C++20)	bestimmt, ob eine Sequenz eine Permutation einer anderen Sequenz ist (Algorithmus-Funktionsobjekt)

Numerische Operationen

Definiert in der Header-Datei <numeric>
iota (C++11)	füllt einen Bereich mit sukzessiven Inkrementen des Startwerts (Funktionstemplate)
ranges::iota (C++23)	füllt einen Bereich mit sukzessiven Inkrementen des Startwerts (Funktionsobjekt für Algorithmen)
accumulate	summiert oder faltet eine Reihe von Elementen (Funktionstemplate)
inner_product	berechnet das innere Produkt von zwei Elementreihen (Funktionstemplate)
adjacent_difference	berechnet die Differenzen zwischen benachbarten Elementen in einer Reihe (Funktionstemplate)
partial_sum	berechnet die partielle Summe einer Elementreihe (Funktionstemplate)
reduce (C++17)	ähnlich wie std::accumulate, aber nicht-sequenziell (Funktionstemplate)
exclusive_scan (C++17)	ähnlich wie std::partial_sum, schließt das i-te Eingabeelement von der i-ten Summe aus (Funktionstemplate)
inclusive_scan (C++17)	ähnlich wie std::partial_sum, schließt das i-te Eingabeelement in die i-te Summe ein (Funktionstemplate)
transform_reduce (C++17)	wendet eine aufrufbare Funktion an und reduziert dann nicht-sequenziell (Funktionstemplate)
transform_exclusive_scan (C++17)	wendet eine aufrufbare Funktion an und berechnet dann einen exklusiven Scan (Funktionstemplate)
transform_inclusive_scan (C++17)	wendet eine aufrufbare Funktion an und berechnet dann einen inklusiven Scan (Funktionstemplate)

Operationen auf uninitialisiertem Speicher

Definiert in Header <memory>
uninitialized_copy	kopiert einen Bereich von Objekten in einen uninitialisierten Speicherbereich (Funktions-Template)
ranges::uninitialized_copy (C++20)	kopiert einen Bereich von Objekten in einen uninitialisierten Speicherbereich (Algorithmus-Funktionsobjekt)
uninitialized_copy_n (C++11)	kopiert eine Anzahl von Objekten in einen uninitialisierten Speicherbereich (Funktions-Template)
ranges::uninitialized_copy_n (C++20)	kopiert eine Anzahl von Objekten in einen uninitialisierten Speicherbereich (Algorithmus-Funktionsobjekt)
uninitialized_fill	kopiert ein Objekt in einen uninitialisierten Speicherbereich, definiert durch einen Bereich (Funktions-Template)
ranges::uninitialized_fill (C++20)	kopiert ein Objekt in einen uninitialisierten Speicherbereich, definiert durch einen Bereich (Algorithmus-Funktionsobjekt)
uninitialized_fill_n	kopiert ein Objekt in einen uninitialisierten Speicherbereich, definiert durch einen Start und eine Anzahl (Funktions-Template)
ranges::uninitialized_fill_n (C++20)	kopiert ein Objekt in einen uninitialisierten Speicherbereich, definiert durch einen Start und eine Anzahl (Algorithmus-Funktionsobjekt)
uninitialized_move (C++17)	verschiebt einen Bereich von Objekten in einen uninitialisierten Speicherbereich (Funktions-Template)
ranges::uninitialized_move (C++20)	verschiebt einen Bereich von Objekten in einen uninitialisierten Speicherbereich (Algorithmus-Funktionsobjekt)
uninitialized_move_n (C++17)	verschiebt eine Anzahl von Objekten in einen uninitialisierten Speicherbereich (Funktions-Template)
ranges::uninitialized_move_n (C++20)	verschiebt eine Anzahl von Objekten in einen uninitialisierten Speicherbereich (Algorithmus-Funktionsobjekt)
uninitialized_default_construct (C++17)	konstruiert Objekte mittels Standardinitialisierung in einem uninitialisierten Speicherbereich, definiert durch einen Bereich (Funktions-Template)
ranges::uninitialized_default_construct (C++20)	konstruiert Objekte mittels Standardinitialisierung in einem uninitialisierten Speicherbereich, definiert durch einen Bereich (Algorithmus-Funktionsobjekt)
uninitialized_default_construct_n (C++17)	konstruiert Objekte mittels Standardinitialisierung in einem uninitialisierten Speicherbereich, definiert durch einen Start und eine Anzahl (Funktions-Template)
ranges::uninitialized_default_construct_n (C++20)	konstruiert Objekte mittels Standardinitialisierung in einem uninitialisierten Speicherbereich, definiert durch Start und Anzahl (Algorithmus-Funktionsobjekt)
uninitialized_value_construct (C++17)	konstruiert Objekte mittels Wertinitialisierung in einem uninitialisierten Speicherbereich, definiert durch einen Bereich (Funktions-Template)
ranges::uninitialized_value_construct (C++20)	konstruiert Objekte mittels Wertinitialisierung in einem uninitialisierten Speicherbereich, definiert durch einen Bereich (Algorithmus-Funktionsobjekt)
uninitialized_value_construct_n (C++17)	konstruiert Objekte mittels Wertinitialisierung in einem uninitialisierten Speicherbereich, definiert durch einen Start und eine Anzahl (Funktions-Template)
ranges::uninitialized_value_construct_n (C++20)	konstruiert Objekte mittels Wertinitialisierung in einem uninitialisierten Speicherbereich, definiert durch einen Start und eine Anzahl (Algorithmus-Funktionsobjekt)
destroy (C++17)	zerstört einen Bereich von Objekten (Funktions-Template)
ranges::destroy (C++20)	zerstört einen Bereich von Objekten (Algorithmus-Funktionsobjekt)
destroy_n (C++17)	zerstört eine Anzahl von Objekten in einem Bereich (Funktions-Template)
ranges::destroy_n (C++20)	zerstört eine Anzahl von Objekten in einem Bereich (Algorithmus-Funktionsobjekt)
destroy_at (C++17)	zerstört ein Objekt an einer gegebenen Adresse (Funktions-Template)
ranges::destroy_at (C++20)	zerstört ein Objekt an einer gegebenen Adresse (Algorithmus-Funktionsobjekt)
construct_at (C++20)	erstellt ein Objekt an einer gegebenen Adresse (Funktions-Template)
ranges::construct_at (C++20)	erstellt ein Objekt an einer gegebenen Adresse (Algorithmus-Funktionsobjekt)

Zufallszahlengenerierung (seit C++26)

Definiert in Header <random>
ranges::generate_random (C++26)	füllt einen Bereich mit Zufallszahlen aus einem gleichmäßigen Zufalls-Bit-Generator (Algorithmus-Funktionsobjekt)

Anmerkungen

Feature-Test-Makro	Wert	Std	Feature
__cpp_lib_algorithm_iterator_requirements	202207L	(C++23)	Bereichsiteratoren als Eingaben für Nicht-Bereichs-Algorithmen
__cpp_lib_clamp	201603L	(C++17)	std::clamp
__cpp_lib_constexpr_algorithms	201806L	(C++20)	Constexpr für Algorithmen
	202306L	(C++26)	Constexpr stabile Sortierung
__cpp_lib_algorithm_default_value_type	202403L	(C++26)	Listeninitialisierung für Algorithmen
__cpp_lib_freestanding_algorithm	202311L	(C++26)	Freistehende Einrichtungen in <algorithm>
__cpp_lib_robust_nonmodifying_seq_ops	201304L	(C++14)	Robustere nicht-modifizierende Sequenzoperationen (Zwei-Bereichs-Ü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 in Header <cstdlib>
qsort	sortiert einen Bereich von Elementen unbekannten Typs (Funktion)
bsearch	sucht ein Array nach einem Element unbekannten Typs ab (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, dass *first das größte Element ist	es kann Elemente geben gleich *first
LWG 2150	C++98	die Definition einer sortierten Sequenz war fehlerhaft	korrigiert
LWG 2166	C++98	die Heap-Anforderung stimmte nicht mit der Definition von Max Heap eng genug überein	Anforderung verbessert

Siehe auch

C-Dokumentation für Algorithmen