Algorithmes contraints (depuis C++20)
Depuis fr.cppreference.net
C++20 fournit des contraintes versions 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 seul argument plage, et les projections et les objets appelables pointeur vers membre sont pris en charge. De plus, les types de retour de la plupart des algorithmes ont été modifiés pour retourner toutes les informations potentiellement utiles calculées pendant l'exécution de l'algorithme.
Objets de fonction d'algorithme
Un objet de fonction d'algorithme (AFO), informellement appelé niebloïde , est un objet point de personnalisation (CPO) qui est spécifié comme un ou plusieurs modèles de fonction surchargés. Le nom de ces modèles de fonction désigne l'objet de fonction d'algorithme correspondant.
Pour un objet de fonction d'algorithme o, soit S l'ensemble correspondant de modèles de fonction. Alors pour toute séquence d'arguments args..., o(args...) est équivalent à une expression à s(args...), où le résultat de la recherche de nom pour s est l'ensemble de surcharge S.
Les algorithmes contraints dans l'espace de noms std::ranges sont définis comme des objets de fonction d'algorithme. En conséquence :
- Les listes d'arguments de modèle explicites ne peuvent pas être spécifiées lors de l'appel de l'un d'entre eux.
- Aucun d'entre eux n'est visible par recherche dépendante des arguments.
- Lorsque l'un d'entre eux est trouvé par recherche normale non qualifiée comme le nom à gauche de l'opérateur d'appel de fonction, la recherche dépendante des arguments est inhibée.
Paramètres de plage
Certaines surcharges prennent plage arguments, elles se comportent comme si elles étaient implémentées en déléguant à la surcharge correspondante dans l'espace de noms ranges qui prend des arguments séparés d'itérateur et de sentinelle, où pour chaque argument de plage r:
- L'argument itérateur correspondant est initialisé avec
ranges::begin(r).
|
(jusqu'à C++26) |
|
(depuis C++26) |
Opérations de séquence non modifiantes
Défini dans l'en-tête
<algorithm> | |
Défini dans l'espace de noms
std::ranges | |
Opérations par lots | |
(C++20) |
applique un objet fonction unaire aux éléments d'une plage (objet fonction d'algorithme) |
(C++20) |
applique un objet fonction aux N premiers éléments d'une séquence (objet fonction d'algorithme) |
Opérations de recherche | |
(C++20)(C++20)(C++20) |
vérifie si un prédicat est vrai pour tous, au moins un ou aucun des éléments d'une plagetrue(objet fonction d'algorithme)ranges::contains |
(C++23)vérifie si la plage contient l'élément ou la sous-plage donné(e) |
(objet fonction d'algorithme) ranges::find |
(C++20)(C++20)trouve le premier élément satisfaisant des critères spécifiques |
(objet fonction d'algorithme) ranges::find_last |
(C++23)(C++23)trouve le dernier élément satisfaisant des critères spécifiques |
(objet fonction d'algorithme) ranges::find_end |
trouve la dernière séquence d'éléments dans une plage donnée |
(objet fonction d'algorithme) ranges::find_first_of |
recherche l'un quelconque des éléments d'un ensemble |
(objet fonction d'algorithme) ranges::adjacent_find |
trouve les deux premiers éléments adjacents qui sont égaux (ou satisfont un prédicat donné) |
(objet fonction d'algorithme) ranges::count |
(C++20)renvoie le nombre d'éléments satisfaisant des critères spécifiques |
(objet fonction d'algorithme) ranges::mismatch |
trouve la première position où deux plages diffèrent |
(objet fonction d'algorithme) ranges::equal |
détermine si deux ensembles d'éléments sont identiques |
(objet fonction d'algorithme) ranges::search |
recherche la première occurrence d'une plage d'éléments |
(objet fonction d'algorithme) ranges::search_n |
recherche la première occurrence d'un nombre donné de copies consécutives d'un élément dans une plage |
(objet fonction d'algorithme) ranges::starts_with |
vérifie si une plage commence par une autre plage |
(objet fonction d'algorithme) ranges::ends_with |
vérifie si une plage se termine par une autre plage |
(objet fonction d'algorithme) |
Opérations de pliage | |
(C++23) |
effectue un pliage gauche d'une plage d'éléments (objet fonction d'algorithme) |
(C++23) |
effectue un pliage gauche d'une plage d'éléments en utilisant le premier élément comme valeur initiale (objet fonction d'algorithme) |
(C++23) |
effectue un pliage droit d'une plage d'éléments (objet fonction d'algorithme) |
(C++23) |
effectue un pliage droit d'une plage d'éléments en utilisant le dernier élément comme valeur initiale (objet fonction d'algorithme) |
(C++23) |
effectue un pliage gauche d'une plage d'éléments, et renvoie une pair (itérateur, valeur) (objet fonction d'algorithme) |
| effectue un pliage gauche d'une plage d'éléments en utilisant le premier élément comme valeur initiale, et renvoie une pair (itérateur, optional) (objet fonction d'algorithme) | |
Opérations de modification de séquence
Défini dans l'en-tête
<algorithm> | |
Défini dans l'espace de noms
std::ranges | |
Opérations de copie | |
(C++20)(C++20) |
copie une plage d'éléments vers un nouvel emplacement (objet fonction d'algorithme) |
(C++20) |
copie un nombre d'éléments vers un nouvel emplacement (objet fonction d'algorithme) |
(C++20) |
copie une plage d'éléments en ordre inverse (objet fonction d'algorithme) |
(C++20) |
déplace une plage d'éléments vers un nouvel emplacement (objet fonction d'algorithme) |
(C++20) |
déplace une plage d'éléments vers un nouvel emplacement en ordre inverse (objet fonction d'algorithme) |
Opérations d'échange | |
(C++20) |
échange deux plages d'éléments (objet fonction d'algorithme) |
Opérations de transformation | |
(C++20) |
applique une fonction à une plage d'éléments (objet fonction d'algorithme) |
(C++20)(C++20) |
remplace toutes les valeurs satisfaisant des critères spécifiques par une autre valeur (objet fonction d'algorithme) |
(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 d'algorithme) |
Opérations de génération | |
(C++20) |
affecte une certaine valeur à une plage d'éléments (objet fonction d'algorithme) |
(C++20) |
affecte une valeur à un nombre d'éléments (objet fonction d'algorithme) |
(C++20) |
enregistre le résultat d'une fonction dans une plage (objet fonction d'algorithme) |
(C++20) |
enregistre le résultat de N applications d'une fonction (objet fonction d'algorithme) |
Opérations de suppression | |
(C++20)(C++20) |
supprime les éléments répondant à des critères spécifiques (objet fonction d'algorithme) |
(C++20)(C++20) |
copie une plage d'éléments en omettant ceux qui répondent à des critères spécifiques (objet fonction d'algorithme) |
(C++20) |
supprime les éléments dupliqués consécutifs dans une plage (objet fonction d'algorithme) |
(C++20) |
crée une copie d'une plage d'éléments sans doublons consécutifs (objet fonction d'algorithme) |
Opérations de changement d'ordre | |
(C++20) |
inverse l'ordre des éléments dans une plage (algorithm function object) |
(C++20) |
crée une copie inversée d'une plage (algorithm function object) |
(C++20) |
fait pivoter l'ordre des éléments dans une plage (algorithm function object) |
(C++20) |
copie et fait pivoter une plage d'éléments (algorithm function object) |
(C++23)(C++23) |
décale les éléments dans une plage (algorithm function object) |
(C++20) |
réorganise aléatoirement les éléments dans une plage (algorithm function object) |
Opérations d'échantillonnage | |
(C++20) |
sélectionne N éléments aléatoires d'une séquence (objet fonction d'algorithme) |
Défini dans l'en-tête
<algorithm> | |
Défini dans l'espace de noms
std::ranges | |
Opérations de partitionnement | |
(C++20) |
détermine si la plage est partitionnée par le prédicat donné (objet fonction d'algorithme) |
(C++20) |
divise une plage d'éléments en deux groupes (objet fonction d'algorithme) |
(C++20) |
copie une plage en divisant les éléments en deux groupes (objet fonction d'algorithme) |
(C++20) |
divise les éléments en deux groupes tout en préservant leur ordre relatif au sein de chaque groupe (objet fonction d'algorithme) |
(C++20) |
localise le point de partition d'une plage partitionnée (objet fonction d'algorithme) |
Opérations de tri | |
(C++20) |
vérifie si une plage est triée (objet fonction d'algorithme) |
(C++20) |
trouve la plus grande sous-plage triée (objet fonction d'algorithme) |
(C++20) |
trie une plage d'éléments (objet fonction d'algorithme) |
(C++20) |
trie les N premiers éléments d'une plage (objet fonction d'algorithme) |
(C++20) |
copie et trie partiellement une plage d'éléments (objet fonction d'algorithme) |
(C++20) |
trie une plage d'éléments tout en préservant l'ordre relatif des éléments équivalents (objet fonction d'algorithme) |
(C++20) |
trouve le Nième élément si la plage était triée (objet fonction d'algorithme) |
Opérations de recherche binaire (sur des plages triées) | |
(C++20) |
trouve le premier élément non inférieur à la valeur donnée en utilisant la recherche binaire (objet de fonction d'algorithme) |
(C++20) |
trouve le premier élément supérieur à la valeur donnée en utilisant la recherche binaire (objet de fonction d'algorithme) |
(C++20) |
détermine si un élément existe dans une plage en utilisant la recherche binaire (objet de fonction d'algorithme) |
(C++20) |
trouve la plage d'éléments correspondant à la valeur donnée en utilisant la recherche binaire (objet de fonction d'algorithme) |
Opérations ensemblistes (sur des plages triées) | |
(C++20) |
détermine si une séquence est une sous-séquence d'une autre (objet fonction d'algorithme) |
(C++20) |
calcule la différence entre deux ensembles (objet fonction d'algorithme) |
(C++20) |
calcule l'intersection de deux ensembles (objet fonction d'algorithme) |
| calcule la différence symétrique entre deux ensembles (objet fonction d'algorithme) | |
(C++20) |
calcule l'union de deux ensembles (objet fonction d'algorithme) |
Opérations de fusion (sur des plages triées) | |
(C++20) |
fusionne deux plages triées (objet fonction d'algorithme) |
(C++20) |
fusionne deux plages ordonnées en place (objet fonction d'algorithme) |
Opérations sur les tas | |
(C++20) |
vérifie si la plage donnée est un tas max (objet fonction d'algorithme) |
(C++20) |
trouve la plus grande sous-plage qui est un tas max (objet fonction d'algorithme) |
(C++20) |
crée un tas max à partir d'une plage d'éléments (objet fonction d'algorithme) |
(C++20) |
ajoute un élément à un tas max (objet fonction d'algorithme) |
(C++20) |
supprime le plus grand élément d'un tas max (objet fonction d'algorithme) |
(C++20) |
transforme un tas max en une plage d'éléments triée (objet fonction d'algorithme) |
Opérations minimum/maximum |
|
|
(C++20)
|
retourne la plus grande des valeurs données
(objet fonction algorithme) |
|
(C++20)
|
retourne le plus grand élément dans une plage
(objet fonction algorithme) |
|
(C++20)
|
renvoie la plus petite des valeurs données
(objet fonction algorithme) |
|
(C++20)
|
renvoie le plus petit élément dans une plage
(objet fonction algorithme) |
|
(C++20)
|
retourne le plus petit et le plus grand de deux éléments
(fonction objet d'algorithm) |
|
(C++20)
|
retourne les plus petits et les plus grands éléments dans une plage
(objet fonction algorithme) |
|
(C++20)
|
limite une valeur entre une paire de valeurs limites
(objet fonction algorithme) |
Opérations de comparaison lexicographique | |
| compare deux plages lexicographiquement (objet fonction d'algorithme) | |
Opérations de permutation |
|
|
(C++20)
|
détermine si une séquence est une permutation d'une autre séquence
(objet fonction algorithme) |
|
(C++20)
|
génère la prochaine permutation lexicographique supérieure d'une plage d'éléments
(objet fonction algorithme) |
|
(C++20)
|
génère la permutation lexicographique précédente d'une plage d'éléments
(objet fonction algorithme) |
Opérations numériques
Définie dans l'en-tête
<numeric> | |
Définie dans l'espace de noms
std::ranges | |
(C++23) |
remplit une plage avec des incréments successifs de la valeur de départ (objet fonction d'algorithme) |
Spécialisés <memory> algorithmes
Défini dans l'en-tête
<memory> | |
Défini dans l'espace de noms
std::ranges | |
Construction d'objets (par lots) | |
(C++20) |
crée un objet à une adresse donnée (objet fonction d'algorithme) |
(C++20) |
copie une plage d'objets vers une zone mémoire non initialisée (objet fonction d'algorithme) |
(C++20) |
copie un nombre d'objets vers une zone mémoire non initialisée (objet fonction d'algorithme) |
(C++20) |
copie un objet vers une zone mémoire non initialisée, définie par une plage (objet fonction d'algorithme) |
(C++20) |
copie un objet vers une zone mémoire non initialisée, définie par un début et un nombre (objet fonction d'algorithme) |
(C++20) |
déplace une plage d'objets vers une zone mémoire non initialisée (objet fonction d'algorithme) |
(C++20) |
déplace un nombre d'objets vers une zone mémoire non initialisée (objet fonction d'algorithme) |
| construit des objets par initialisation par défaut dans une zone mémoire non initialisée, définie par une plage (objet fonction d'algorithme) | |
| construit des objets par initialisation par défaut dans une zone mémoire non initialisée, définie par un début et un nombre (objet fonction d'algorithme) | |
| construit des objets par initialisation par valeur dans une zone mémoire non initialisée, définie par une plage (objet fonction d'algorithme) | |
| construit des objets par initialisation par valeur dans une zone mémoire non initialisée, définie par un début et un nombre (objet fonction d'algorithme) | |
Destruction d'objets (par lot) | |
(C++20) |
détruit un intervalle d'objets (objet fonction d'algorithme) |
(C++20) |
détruit un nombre d'objets dans un intervalle (objet fonction d'algorithme) |
(C++20) |
détruit un objet à une adresse donnée (objet fonction d'algorithme) |
Spécialisés <random>algorithmes
Défini dans l'en-tête
<random> | |
Défini dans l'espace de noms
std::ranges | |
(C++26) |
remplit une plage avec des nombres aléatoires provenant d'un générateur de bits aléatoires uniformes (objet fonction d'algorithme) |
Types de retour
|
Défini dans l'en-tête
<algorithm>
|
|
|
Défini dans l'espace de noms
std::ranges
|
|
|
(C++20)
|
fournit un moyen de stocker un itérateur et un objet fonction comme une seule unité
(modèle de classe) |
|
(C++20)
|
fournit un moyen de stocker deux itérateurs comme une seule unité
(modèle de classe) |
|
(C++20)
|
fournit un moyen de stocker deux itérateurs comme une seule unité
(modèle de classe) |
|
(C++20)
|
fournit un moyen de stocker trois itérateurs comme une seule unité
(modèle de classe) |
|
(C++20)
|
fournit un moyen de stocker trois itérateurs comme une seule unité
(modèle de classe) |
|
(C++20)
|
fournit un moyen de stocker deux objets ou références du même type comme une seule unité
(modèle de classe) |
|
(C++20)
|
fournit un moyen de stocker un itérateur et un drapeau booléen comme une seule unité
(modèle de classe) |
|
(C++23)
|
fournit un moyen de stocker un itérateur et une valeur comme une seule unité
(modèle de classe) |
|
(C++23)
|
fournit un moyen de stocker un itérateur et une valeur comme une seule unité
(modèle de classe) |
Notes
| Feature-test macro | Valeur | Std | Fonctionnalité |
|---|---|---|---|
__cpp_lib_algorithm_default_value_type |
202403L |
(C++26) | Initialisation par liste pour les algorithmes |
__cpp_lib_parallel_algorithm |
202506L |
(C++26) | Parallèles algorithmes de range |
__cpp_lib_ranges |
201911L |
(C++20) | Bibliothèque Ranges et algorithmes contraints |
__cpp_lib_ranges_contains |
202207L |
(C++23) | std::ranges::contains |
__cpp_lib_ranges_find_last |
202207L |
(C++23) | std::ranges::find_last |
__cpp_lib_ranges_fold |
202207L |
(C++23) | std::ranges fold algorithmes
|
__cpp_lib_ranges_iota |
202202L |
(C++23) | std::ranges::iota |
__cpp_lib_ranges_starts_ends_with |
202106L |
(C++23) | std::ranges::starts_with, std::ranges::ends_with |
__cpp_lib_shift |
201806L |
(C++20) | std::shift_left, std::shift_right |
202202L |
(C++23) | std::ranges::shift_left, std::ranges::shift_right | |
__cpp_lib_ranges_generate_random |
202403L |
(C++26) | std::ranges::generate_random |
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 tel que publié | Comportement correct |
|---|---|---|---|
| P3136R1 | C++20 | niebloids étaient autorisés à être spécifiés comme entités spéciales autres que des objets fonctions |
devaient être spécifiés comme des objets fonctions |