Namespaces
Variants

Algorithms library

From cppreference.net
C++
Algorithm library
Constrained algorithms and algorithms on ranges (C++20)
Constrained algorithms, e.g. ranges::copy , ranges::sort , ...
Execution policies (C++17)
Non-modifying sequence operations
Batch operations
(C++17)
Search operations
Modifying sequence operations
Copy operations
(C++11)
(C++11)
(C++11)
Swap operations
Transformation operations
Generation operations
Removing operations
Order-changing operations
(until C++17) (C++11)
(C++20) (C++20)
Sampling operations
(C++17)

Sorting and related operations
Partitioning operations
Sorting operations
Binary search operations
(on partitioned ranges)
Set operations (on sorted ranges)
Merge operations (on sorted ranges)
Heap operations
Minimum/maximum operations
Lexicographical comparison operations
(C++20)
Permutation operations
C library
Numeric operations
Operations on uninitialized memory

La bibliothèque d'algorithmes définit des fonctions pour diverses finalités (par exemple, recherche, tri, comptage, manipulation) qui opèrent sur des plages d'éléments. Notez qu'une plage est définie comme [ first , last ) où last fait référence à l'élément après le dernier élément à inspecter ou modifier.

Table des matières

Algorithmes contraints (depuis C++20)

C++20 fournit des versions contraintes de la plupart des algorithmes dans l'espace de noms std::ranges . Dans ces algorithmes, une plage peut être spécifiée soit comme une paire itérateur - sentinelle , soit comme un unique argument de range , et les projections ainsi que les objets appelables pointeur-sur-membre sont pris en charge. De plus, les types de retour de la plupart des algorithmes ont été modifiés pour renvoyer toutes les informations potentiellement utiles calculées durant l'exécution de l'algorithme. 

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

Politiques d'exécution (depuis C++17)

La plupart des algorithmes disposent de surcharges qui acceptent des politiques d'exécution. Les algorithmes de la bibliothèque standard prennent en charge plusieurs politiques d'exécution , et la bibliothèque fournit les types et objets de politique d'exécution correspondants. Les utilisateurs peuvent sélectionner une politique d'exécution statiquement en invoquant un algorithme parallèle avec un objet de politique d'exécution du type correspondant.

Les implémentations de la bibliothèque standard (mais pas les utilisateurs) peuvent définir des politiques d'exécution supplémentaires en tant qu'extension. La sémantique des algorithmes parallèles invoqués avec un objet de politique d'exécution de type défini par l'implémentation est spécifique à l'implémentation.

Les versions parallèles des algorithmes (à l'exception de std::for_each et std::for_each_n ) sont autorisées à effectuer des copies arbitraires des éléments des plages, tant que std:: is_trivially_copy_constructible_v < T > et std:: is_trivially_destructible_v < T > sont true , où T est le type des éléments.

Défini dans l'en-tête <execution>
Défini dans l'espace de noms std::execution
(C++17) (C++17) (C++17) (C++20)
types de politiques d'exécution
(classe)
(C++17) (C++17) (C++17) (C++20)
objets globaux de politique d'exécution
(constante)
Défini dans l'espace de noms std
(C++17)
teste si une classe représente une politique d'exécution
(modèle de classe)
Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_parallel_algorithm 201603L (C++17) Algorithmes parallèles
__cpp_lib_execution 201603L (C++17) Politiques d'exécution
201902L (C++20) std::execution::unsequenced_policy

Opérations de séquence non modifiantes

Opérations par lots

Défini dans l'en-tête <algorithm>
applique un objet fonction unaire aux éléments d'un intervalle
(modèle de fonction)
(C++20)
applique un objet fonction unaire aux éléments d'un intervalle
(objet fonction d'algorithme)
(C++17)
applique un objet fonction aux N premiers éléments d'une séquence
(modèle de fonction)
(C++20)
applique un objet fonction aux N premiers éléments d'une séquence
(objet fonction d'algorithme)

Opérations de recherche

Défini dans l'en-tête <algorithm>
(C++11) (C++11) (C++11)
vérifie si un prédicat est true pour tous, certains ou aucun des éléments dans une plage
(modèle de fonction)
(C++20) (C++20) (C++20)
vérifie si un prédicat est true pour tous, certains ou aucun des éléments d'une plage
(objet fonction algorithme)
(C++23) (C++23)
vérifie si la plage contient l'élément ou la sous-plage donnée
(objet fonction algorithme)
(C++11)
trouve le premier élément satisfaisant des critères spécifiques
(modèle de fonction)
(C++20) (C++20) (C++20)
trouve le premier élément satisfaisant des critères spécifiques
(objet fonction algorithme)
(C++23) (C++23) (C++23)
trouve le dernier élément satisfaisant des critères spécifiques
(objet fonction algorithme)
trouve la dernière séquence d'éléments dans une certaine plage
(modèle de fonction)
(C++20)
trouve la dernière séquence d'éléments dans une certaine plage
(objet fonction algorithme)
recherche l'un quelconque des éléments d'un ensemble
(modèle de fonction)
(C++20)
recherche l'un quelconque des éléments d'un ensemble
(objet fonction algorithme)
trouve les deux premiers éléments adjacents qui sont égaux (ou qui satisfont un prédicat donné)
(modèle de fonction)
(C++20)
trouve les deux premiers éléments adjacents qui sont égaux (ou satisfont un prédicat donné)
(objet fonction algorithme)
renvoie le nombre d'éléments satisfaisant des critères spécifiques
(modèle de fonction)
(C++20) (C++20)
retourne le nombre d'éléments satisfaisant des critères spécifiques
(objet fonction algorithme)
trouve la première position où deux plages diffèrent
(modèle de fonction)
(C++20)
trouve la première position où deux plages diffèrent
(objet fonction algorithme)
détermine si deux ensembles d'éléments sont identiques
(modèle de fonction)
(C++20)
détermine si deux ensembles d'éléments sont identiques
(objet fonction algorithme)
recherche la première occurrence d'une plage d'éléments
(fonction template)
(C++20)
recherche la première occurrence d'une plage d'éléments
(objet fonction algorithme)
recherche la première occurrence d'un nombre de copies consécutives d'un élément dans une plage
(modèle de fonction)
(C++20)
recherche la première occurrence d'un nombre de copies consécutives d'un élément dans une plage
(objet fonction algorithme)
(C++23)
vérifie si une plage commence par une autre plage
(objet fonction algorithme)
(C++23)
vérifie si une plage se termine par une autre plage
(objet fonction algorithme)

Opérations de repli (depuis C++23)

Défini dans l'en-tête <algorithm>
(C++23)
réduit à gauche une plage d'éléments
(objet fonction algorithme)
(C++23)
réduit à gauche une plage d'éléments en utilisant le premier élément comme valeur initiale
(objet fonction algorithme)
(C++23)
réduit à droite une plage d'éléments
(objet fonction algorithme)
(C++23)
réduit à droite une plage d'éléments en utilisant le dernier élément comme valeur initiale
(objet fonction algorithme)
(C++23)
réduit à gauche une plage d'éléments et retourne une paire (itérateur, valeur)
(objet fonction algorithme)
(C++23)
réduit à gauche une plage d'éléments en utilisant le premier élément comme valeur initiale et retourne une paire (itérateur, optional )
(objet fonction algorithme)

Opérations de modification de séquence

Opérations de copie

Défini dans l'en-tête <algorithm>
(C++11)
copie une plage d'éléments vers un nouvel emplacement
(modèle de fonction)
(C++20) (C++20)
copie une plage d'éléments vers un nouvel emplacement
(objet fonction algorithme)
(C++11)
copie un nombre d'éléments vers un nouvel emplacement
(modèle de fonction)
(C++20)
copie un nombre d'éléments vers un nouvel emplacement
(objet fonction algorithme)
copie une plage d'éléments dans l'ordre inverse
(modèle de fonction)
(C++20)
copie une plage d'éléments dans l'ordre inverse
(objet fonction algorithme)
(C++11)
déplace une plage d'éléments vers un nouvel emplacement
(modèle de fonction)
(C++20)
déplace une plage d'éléments vers un nouvel emplacement
(objet fonction algorithme)
(C++11)
déplace une plage d'éléments vers un nouvel emplacement dans l'ordre inverse
(modèle de fonction)
(C++20)
déplace une plage d'éléments vers un nouvel emplacement dans l'ordre inverse
(objet fonction algorithme)

Opérations d'échange

Défini dans l'en-tête <algorithm> (jusqu'à C++11)
Défini dans l'en-tête <utility> (depuis C++11)
Défini dans l'en-tête <string_view>
échange les valeurs de deux objets
(modèle de fonction)
Défini dans l'en-tête <algorithm>
échange deux plages d'éléments
(modèle de fonction)
(C++20)
échange deux plages d'éléments
(objet fonction algorithme)
échange les éléments pointés par deux itérateurs
(modèle de fonction)

Opérations de transformation

Défini dans l'en-tête <algorithm>
applique une fonction à une plage d'éléments, stockant les résultats dans une plage de destination
(modèle de fonction)
(C++20)
applique une fonction à une plage d'éléments
(objet fonction algorithme)
remplace toutes les valeurs satisfaisant des critères spécifiques par une autre valeur
(modèle de fonction)
(C++20) (C++20)
remplace toutes les valeurs satisfaisant des critères spécifiques par une autre valeur
(objet fonction algorithme)
copie une plage en remplaçant les éléments satisfaisant des critères spécifiques par une autre valeur
(modèle de fonction)
(C++20) (C++20)
copie une plage en remplaçant les éléments satisfaisant des critères spécifiques par une autre valeur
(objet fonction algorithme)

Opérations de génération

Défini dans l'en-tête <algorithm>
assigne par copie la valeur donnée à chaque élément d'une plage
(modèle de fonction)
(C++20)
assigne une valeur à une plage d'éléments
(objet fonction algorithme)
assigne par copie la valeur donnée à N éléments d'une plage
(modèle de fonction)
(C++20)
assigne une valeur à un nombre d'éléments
(objet fonction algorithme)
assigne les résultats d'appels successifs de fonction à chaque élément d'une plage
(modèle de fonction)
(C++20)
sauvegarde le résultat d'une fonction dans une plage
(objet fonction algorithme)
assigne les résultats d'appels successifs de fonction à N éléments d'une plage
(modèle de fonction)
(C++20)
sauvegarde le résultat de N applications d'une fonction
(objet fonction algorithme)

Opérations de suppression

Défini dans l'en-tête <algorithm>
supprime les éléments satisfaisant des critères spécifiques
(modèle de fonction)
(C++20) (C++20)
supprime les éléments satisfaisant des critères spécifiques
(objet fonction algorithme)
copie une plage d'éléments en omettant ceux qui satisfont des critères spécifiques
(modèle de fonction)
(C++20) (C++20)
copie une plage d'éléments en omettant ceux qui satisfont des critères spécifiques
(objet fonction algorithme)
supprime les éléments dupliqués consécutifs dans une plage
(modèle de fonction)
(C++20)
supprime les éléments dupliqués consécutifs dans une plage
(objet fonction algorithme)
crée une copie d'une plage d'éléments qui ne contient pas de doublons consécutifs
(modèle de fonction)
(C++20)
crée une copie d'une plage d'éléments qui ne contient pas de doublons consécutifs
(objet fonction algorithme)

Opérations de modification de l'ordre

Défini dans l'en-tête <algorithm>
inverse l'ordre des éléments dans une plage
(modèle de fonction)
(C++20)
inverse l'ordre des éléments dans une plage
(objet fonction algorithme)
crée une copie inversée d'une plage
(modèle de fonction)
(C++20)
crée une copie inversée d'une plage
(objet fonction algorithme)
effectue une rotation des éléments dans une plage
(modèle de fonction)
(C++20)
effectue une rotation des éléments dans une plage
(objet fonction algorithme)
copie et effectue une rotation d'une plage d'éléments
(modèle de fonction)
(C++20)
copie et effectue une rotation d'une plage d'éléments
(objet fonction algorithme)
(C++20)
décale les éléments dans une plage
(modèle de fonction)
(C++23)
décale les éléments dans une plage
(objet fonction algorithme)
(jusqu'en C++17) (C++11)
réordonne aléatoirement les éléments dans une plage
(modèle de fonction)
(C++20)
réordonne aléatoirement les éléments dans une plage
(objet fonction algorithme)

Opérations d'échantillonnage

Défini dans l'en-tête <algorithm>
(C++17)
sélectionne N éléments aléatoires d'une séquence
(modèle de fonction)
(C++20)
sélectionne N éléments aléatoires d'une séquence
(objet fonction algorithme)

Tri et opérations associées

Exigences

Certains algorithmes exigent que la séquence représentée par les arguments soit « triée » ou « partitionnée ». Le comportement est indéfini si cette exigence n'est pas respectée.

Une séquence est triée par rapport à un comparateur comp si pour tout itérateur iter pointant vers la séquence et tout entier non négatif n tel que iter + n [1] est un itérateur valide pointant vers un élément de la séquence, comp ( * ( iter + n ) , * iter ) == false [1] .

(jusqu'en C++20)

Une séquence est triée par rapport à comp et proj pour un comparateur comp et une projection proj si pour tout itérateur iter pointant vers la séquence et tout entier non négatif n tel que iter + n [1] est un itérateur valide pointant vers un élément de la séquence, bool ( std:: invoke ( comp, std:: invoke ( proj, * ( iter + n ) ) ,
std:: invoke ( proj, * iter ) ) ) [1] est false .

Une séquence est triée par rapport à un comparateur comp si la séquence est triée par rapport à comp et std:: identity { } (la projection identité).

(depuis C++20)

Une séquence [ start , finish ) est partitionnée par rapport à une expression f ( e ) s'il existe un entier n tel que pour tout i dans [ ​ 0 ​ , std:: distance ( start, finish ) ) , f ( * ( start + i ) ) [1] est true si et seulement si i < n .

  1. ↑ 1.0 1.1 1.2 1.3 1.4 iter + n signifie simplement « le résultat de iter incrémenté n fois », indépendamment du fait que iter soit un itérateur à accès aléatoire.

Opérations de partitionnement

Défini dans l'en-tête <algorithm>
(C++11)
détermine si la plage est partitionnée par le prédicat donné
(modèle de fonction)
(C++20)
détermine si la plage est partitionnée par le prédicat donné
(objet fonction d'algorithme)
divise une plage d'éléments en deux groupes
(modèle de fonction)
(C++20)
divise une plage d'éléments en deux groupes
(objet fonction d'algorithme)
(C++11)
copie une plage en divisant les éléments en deux groupes
(modèle de fonction)
(C++20)
copie une plage en divisant les éléments en deux groupes
(objet fonction d'algorithme)
divise les éléments en deux groupes en préservant leur ordre relatif
(modèle de fonction)
(C++20)
divise les éléments en deux groupes en préservant leur ordre relatif
(objet fonction d'algorithme)
(C++11)
localise le point de partition d'une plage partitionnée
(modèle de fonction)
(C++20)
localise le point de partition d'une plage partitionnée
(objet fonction d'algorithme)

Opérations de tri

Défini dans l'en-tête <algorithm>
trie une plage en ordre croissant
(modèle de fonction)
(C++20)
trie une plage en ordre croissant
(objet fonction algorithme)
trie une plage d'éléments en préservant l'ordre entre les éléments égaux
(modèle de fonction)
(C++20)
trie une plage d'éléments en préservant l'ordre entre les éléments égaux
(objet fonction algorithme)
trie les N premiers éléments d'une plage
(modèle de fonction)
(C++20)
trie les N premiers éléments d'une plage
(objet fonction algorithme)
copie et trie partiellement une plage d'éléments
(modèle de fonction)
(C++20)
copie et trie partiellement une plage d'éléments
(objet fonction algorithme)
(C++11)
vérifie si une plage est triée en ordre croissant
(modèle de fonction)
(C++20)
vérifie si une plage est triée en ordre croissant
(objet fonction algorithme)
(C++11)
trouve la plus grande sous-plage triée
(modèle de fonction)
(C++20)
trouve la plus grande sous-plage triée
(objet fonction algorithme)
trie partiellement la plage donnée en s'assurant qu'elle est partitionnée par l'élément donné
(modèle de fonction)
(C++20)
trie partiellement la plage donnée en s'assurant qu'elle est partitionnée par l'élément donné
(objet fonction algorithme)

Opérations de recherche binaire (sur des plages partitionnées)

Défini dans l'en-tête <algorithm>
retourne un itérateur vers le premier élément non inférieur à la valeur donnée
(modèle de fonction)
(C++20)
retourne un itérateur vers le premier élément non inférieur à la valeur donnée
(objet fonction algorithme)
retourne un itérateur vers le premier élément supérieur à une certaine valeur
(modèle de fonction)
(C++20)
retourne un itérateur vers le premier élément supérieur à une certaine valeur
(objet fonction algorithme)
retourne la plage d'éléments correspondant à une clé spécifique
(modèle de fonction)
(C++20)
retourne la plage d'éléments correspondant à une clé spécifique
(objet fonction algorithme)
détermine si un élément existe dans une plage partiellement ordonnée
(modèle de fonction)
(C++20)
détermine si un élément existe dans une plage partiellement ordonnée
(objet fonction algorithme)

Opérations sur les ensembles (sur des plages triées)

Défini dans l'en-tête <algorithm>
renvoie true si une séquence est une sous-séquence d'une autre
(modèle de fonction)
(C++20)
renvoie true si une séquence est une sous-séquence d'une autre
(objet fonction d'algorithme)
calcule l'union de deux ensembles
(modèle de fonction)
(C++20)
calcule l'union de deux ensembles
(objet fonction d'algorithme)
calcule l'intersection de deux ensembles
(modèle de fonction)
(C++20)
calcule l'intersection de deux ensembles
(objet fonction d'algorithme)
calcule la différence entre deux ensembles
(modèle de fonction)
(C++20)
calcule la différence entre deux ensembles
(objet fonction d'algorithme)
calcule la différence symétrique entre deux ensembles
(modèle de fonction)
(C++20)
calcule la différence symétrique entre deux ensembles
(objet fonction d'algorithme)

Opérations de fusion (sur des plages triées)

Défini dans l'en-tête <algorithm>
fusionne deux plages triées
(modèle de fonction)
(C++20)
fusionne deux plages triées
(objet fonction algorithme)
fusionne deux plages ordonnées sur place
(modèle de fonction)
(C++20)
fusionne deux plages ordonnées sur place
(objet fonction algorithme)

Opérations de tas

Une plage à accès aléatoire range [ first , last ) est un tas par rapport à un comparateur comp si bool ( comp ( first [ ( i - 1 ) / 2 ] , first [ i ] ) ) est false pour tout entier i dans ( ​ 0 ​ , last - first ) .

(jusqu'à C++20)

Une plage à accès aléatoire range [ first , last ) est un tas par rapport à comp et proj pour un comparateur comp et une projection proj si bool ( std:: invoke ( comp, std:: invoke ( proj, first [ ( i - 1 ) / 2 ] ) ,
std:: invoke ( proj, first [ i ] ) ) est false pour tout entier i dans ( ​ 0 ​ , last - first ) .

Une plage à accès aléatoire range [ first , last ) est un tas par rapport à un comparateur comp si la plage est un tas par rapport à comp et std:: identity { } (la projection identité).

(depuis C++20)

Un tas peut être créé par std::make_heap et ranges::make_heap (depuis C++20) .

Pour plus de propriétés du tas, consultez max heap .


Défini dans l'en-tête <algorithm>
ajoute un élément à un tas max
(modèle de fonction)
(C++20)
ajoute un élément à un tas max
(objet fonction algorithme)
supprime le plus grand élément d'un tas max
(modèle de fonction)
(C++20)
supprime le plus grand élément d'un tas max
(objet fonction algorithme)
crée un tas max à partir d'une plage d'éléments
(modèle de fonction)
(C++20)
crée un tas max à partir d'une plage d'éléments
(objet fonction algorithme)
transforme un tas max en une plage d'éléments triés par ordre croissant
(modèle de fonction)
(C++20)
transforme un tas max en une plage d'éléments triés par ordre croissant
(objet fonction algorithme)
(C++11)
vérifie si la plage donnée est un tas max
(modèle de fonction)
(C++20)
vérifie si la plage donnée est un tas max
(objet fonction algorithme)
(C++11)
trouve la plus grande sous-plage qui est un tas max
(modèle de fonction)
(C++20)
trouve la plus grande sous-plage qui est un tas max
(objet fonction algorithme)

Opérations de minimum/maximum

Défini dans l'en-tête <algorithm>
retourne la plus grande des valeurs données
(modèle de fonction)
(C++20)
retourne la plus grande des valeurs données
(objet fonction algorithme)
retourne le plus grand élément dans une plage
(modèle de fonction)
(C++20)
retourne le plus grand élément dans une plage
(objet fonction algorithme)
retourne la plus petite des valeurs données
(modèle de fonction)
(C++20)
retourne la plus petite des valeurs données
(objet fonction algorithme)
retourne le plus petit élément dans une plage
(modèle de fonction)
(C++20)
retourne le plus petit élément dans une plage
(objet fonction algorithme)
(C++11)
retourne le plus petit et le plus grand de deux éléments
(modèle de fonction)
(C++20)
retourne le plus petit et le plus grand de deux éléments
(objet fonction algorithme)
(C++11)
retourne les plus petits et les plus grands éléments dans une plage
(modèle de fonction)
(C++20)
retourne les plus petits et les plus grands éléments dans une plage
(objet fonction algorithme)
(C++17)
limite une valeur entre une paire de valeurs limites
(modèle de fonction)
(C++20)
limite une valeur entre une paire de valeurs limites
(objet fonction algorithme)

Opérations de comparaison lexicographique

Défini dans l'en-tête <algorithm>
renvoie true si une plage est lexicographiquement inférieure à une autre
(modèle de fonction)
(C++20)
renvoie true si une plage est lexicographiquement inférieure à une autre
(objet fonction algorithme)
(C++20)
compare deux plages en utilisant la comparaison à trois voies
(modèle de fonction)

Opérations de permutation

Défini dans l'en-tête <algorithm>
génère la prochaine permutation lexicographique supérieure d'une plage d'éléments
(modèle de fonction)
(C++20)
génère la prochaine permutation lexicographique supérieure d'une plage d'éléments
(objet fonction algorithme)
génère la prochaine permutation lexicographique inférieure d'une plage d'éléments
(modèle de fonction)
(C++20)
génère la prochaine permutation lexicographique inférieure d'une plage d'éléments
(objet fonction algorithme)
(C++11)
détermine si une séquence est une permutation d'une autre séquence
(modèle de fonction)
(C++20)
détermine si une séquence est une permutation d'une autre séquence
(objet fonction algorithme)

Opérations numériques

Défini dans l'en-tête <numeric>
(C++11)
remplit une plage avec des incréments successifs de la valeur de départ
(modèle de fonction)
(C++23)
remplit une plage avec des incréments successifs de la valeur de départ
(objet fonction algorithme)
additionne ou plie une plage d'éléments
(modèle de fonction)
calcule le produit interne de deux plages d'éléments
(modèle de fonction)
calcule les différences entre les éléments adjacents dans une plage
(modèle de fonction)
calcule la somme partielle d'une plage d'éléments
(modèle de fonction)
(C++17)
similaire à std::accumulate , mais sans ordre
(modèle de fonction)
(C++17)
similaire à std::partial_sum , exclut le i ème élément d'entrée de la i ème somme
(modèle de fonction)
(C++17)
similaire à std::partial_sum , inclut le i ème élément d'entrée dans la i ème somme
(modèle de fonction)
(C++17)
applique un appelable, puis réduit sans ordre
(modèle de fonction)
(C++17)
applique un appelable, puis calcule un scan exclusif
(modèle de fonction)
(C++17)
applique un appelable, puis calcule un scan inclusif
(modèle de fonction)

Opérations sur la mémoire non initialisée

Défini dans l'en-tête <memory>
copie une série d'objets vers une zone mémoire non initialisée
(fonction template)
(C++20)
copie une plage d'objets vers une zone mémoire non initialisée
(objet fonction algorithme)
(C++11)
copie un nombre d'objets vers une zone mémoire non initialisée
(modèle de fonction)
(C++20)
copie un nombre d'objets vers une zone mémoire non initialisée
(objet fonction algorithme)
copie un objet vers une zone mémoire non initialisée, définie par une plage
(modèle de fonction)
(C++20)
copie un objet vers une zone mémoire non initialisée, définie par une plage
(objet fonction algorithme)
copie un objet vers une zone mémoire non initialisée, définie par un début et un compteur
(modèle de fonction)
(C++20)
copie un objet vers une zone mémoire non initialisée, définie par un début et un compteur
(objet fonction algorithme)
(C++17)
déplace une série d'objets vers une zone mémoire non initialisée
(modèle de fonction)
(C++20)
déplace une plage d'objets vers une zone mémoire non initialisée
(objet fonction algorithme)
(C++17)
déplace un nombre d'objets vers une zone de mémoire non initialisée
(modèle de fonction)
(C++20)
déplace un nombre d'objets vers une zone mémoire non initialisée
(objet fonction algorithme)
(C++17)
construit des objets par initialisation par défaut dans une zone mémoire non initialisée, définie par une plage
(modèle de fonction)
(C++20)
construit des objets par default-initialization dans une zone mémoire non initialisée, définie par une plage
(objet fonction algorithme)
(C++17)
construit des objets par default-initialization dans une zone mémoire non initialisée, définie par un début et un compte
(modèle de fonction)
(C++20)
construit des objets par initialisation par défaut dans une zone mémoire non initialisée, définie par un début et un compteur
(objet fonction algorithme)
(C++17)
construit des objets par initialisation par valeur dans une zone mémoire non initialisée, définie par une plage
(fonction template)
(C++20)
construit des objets par value-initialization dans une zone mémoire non initialisée, définie par une plage
(objet fonction algorithme)
(C++17)
construit des objets par value-initialization dans une zone mémoire non initialisée, définie par un début et un compte
(fonction template)
(C++20)
construit des objets par value-initialization dans une zone mémoire non initialisée, définie par un début et un compte
(objet fonction algorithme)
(C++17)
détruit une série d'objets
(modèle de fonction)
(C++20)
détruit une plage d'objets
(objet fonction algorithme)
(C++17)
détruit un nombre d'objets dans une plage
(modèle de fonction)
(C++20)
détruit un nombre d'objets dans une plage
(objet fonction algorithme)
(C++17)
détruit un objet à une adresse donnée
(modèle de fonction)
(C++20)
détruit un objet à une adresse donnée
(objet fonction algorithme)
(C++20)
crée un objet à une adresse donnée
(modèle de fonction)
(C++20)
crée un objet à une adresse donnée
(objet fonction algorithme)

Génération de nombres aléatoires (depuis C++26)

Défini dans l'en-tête <random>
(C++26)
remplit une plage avec des nombres aléatoires provenant d'un générateur de bits aléatoire uniforme
(objet fonction algorithme)

Notes

Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_algorithm_iterator_requirements 202207L (C++23) Itérateurs Ranges en entrée des algorithmes non-Ranges
__cpp_lib_clamp 201603L (C++17) std::clamp
__cpp_lib_constexpr_algorithms 201806L (C++20) Constexpr pour les algorithmes
202306L (C++26) Tri stable constexpr
__cpp_lib_algorithm_default_value_type 202403L (C++26) Initialisation par liste pour les algorithmes
__cpp_lib_freestanding_algorithm 202311L (C++26) Fonctionnalités autonomes dans <algorithm>
__cpp_lib_robust_nonmodifying_seq_ops 201304L (C++14) Rendre les opérations de séquence non modifiantes plus robustes (surcharges à deux plages pour std::mismatch , std::equal et std::is_permutation)
__cpp_lib_sample 201603L (C++17) std::sample
__cpp_lib_shift 201806L (C++20) std::shift_left et std::shift_right

Bibliothèque C

Défini dans l'en-tête <cstdlib>
trie une plage d'éléments de type non spécifié
(fonction)
recherche un élément de type non spécifié dans un tableau
(fonction)

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Appliqué à Comportement publié Comportement corrigé
LWG 193 C++98 le tas exigeait que * first soit le plus grand élément il peut y avoir des éléments
égaux à * first
LWG 2150 C++98 la définition d'une séquence triée était incorrecte corrigée
LWG 2166 C++98 l'exigence de tas ne correspondait pas
suffisamment à la définition du tas maximum 		exigence améliorée

Voir aussi

Documentation C pour Algorithms