Namespaces
Variants

Extensions for ranges

From cppreference.net
C++
Experimental
Ranges

Les Extensions C++ pour les Ranges, ISO/IEC TS 21425:2017, spécifient une modification du langage de base et définissent de nouveaux composants pour la bibliothèque standard C++ listés sur cette page.

Le Ranges TS est basé sur la norme C++14 telle que modifiée par le Concepts TS .

Fusionné dans la norme ISO C++ La fonctionnalité décrite sur cette page a été fusionnée dans la norme principale ISO C++ à partir de 10/2018 ; voir la bibliothèque ranges , la bibliothèque d'algorithmes contraints , et la bibliothèque de concepts fondamentaux (depuis C++20)

Table des matières

Modifications du langage de base

Le Ranges TS modifie la spécification de la boucle for basée sur des intervalles pour permettre des itérateurs de début et de fin de types différents. Ce changement permet l'utilisation de sentinelles et est également présent en C++17.

Concepts

Concepts fondamentaux du langage
Défini dans l'en-tête <experimental/ranges/concepts>
Défini dans l'espace de noms std::experimental::ranges
spécifie qu'un type est identique à un autre type
(concept)
spécifie qu'un type est dérivé d'un autre type
(concept)
spécifie qu'un type est implicitement convertible en un autre type
(concept)
spécifie que deux types partagent un type de référence commun
(concept)
spécifie que deux types partagent un type commun
(concept)
spécifie qu'un type est un type intégral
(concept)
spécifie qu'un type est un type intégral signé
(concept)
spécifie qu'un type est un type intégral qui n'est pas signé
(concept)
spécifie qu'un type peut être assigné à partir d'un autre type
(concept)
spécifie qu'un type peut être échangé ou que deux types peuvent être échangés l'un avec l'autre
(concept)
Concepts de comparaison
Défini dans l'en-tête <experimental/ranges/concepts>
Défini dans l'espace de noms std::experimental::ranges
spécifie qu'un type peut être utilisé dans des contextes booléens
(concept)
spécifie que deux types peuvent être comparés pour l'égalité en utilisant les opérateurs == et ! =
(concept)
spécifie que l'opérateur == est une relation d'équivalence
(concept)
spécifie que les opérateurs de comparaison sur le type produisent un ordre total
(concept)
Concepts d'objet
Défini dans l'en-tête <experimental/ranges/concepts>
Défini dans l'espace de noms std::experimental::ranges
spécifie qu'un objet du type peut être détruit
(concept)
spécifie qu'une variable du type peut être construite à partir ou liée à un ensemble de types d'arguments
(concept)
spécifie qu'un objet d'un type peut être construit par défaut
(concept)
spécifie qu'un objet d'un type peut être construit par déplacement
(concept)
spécifie qu'un objet d'un type peut être copié par construction et déplacé par construction
(concept)
spécifie qu'un objet d'un type peut être déplacé et échangé
(concept)
spécifie qu'un objet d'un type peut être copié, déplacé et échangé
(concept)
spécifie qu'un objet d'un type peut être copié, déplacé, échangé et construit par défaut
(concept)
spécifie qu'un type est régulier, c'est-à-dire qu'il est à la fois Semiregular et EqualityComparable
(concept)
Concepts appelables
Défini dans l'en-tête <experimental/ranges/concepts>
Défini dans l'espace de noms std::experimental::ranges
spécifie qu'un type appelable peut être invoqué avec un ensemble donné de types d'arguments
(concept)
spécifie qu'un type appelable est un prédicat booléen
(concept)
spécifie qu'un type appelable est une relation binaire
(concept)
spécifie qu'une Relation impose un ordre strict faible
(concept)
Concept de générateur de nombres aléatoires
Défini dans l'en-tête <experimental/ranges/random>
Défini dans l'espace de noms std::experimental::ranges
spécifie qu'un type est qualifié en tant que générateur de nombres aléatoires uniforme
(concept)

Utilitaires généraux

Composants utilitaires
Défini dans l'en-tête <experimental/ranges/utility>
Défini dans l'espace de noms std::experimental::ranges
échange la valeur de deux objets
(point de personnalisation d'objet)
remplace l'argument par une nouvelle valeur et retourne sa valeur précédente
(modèle de fonction)
Objets fonction
Défini dans l'en-tête <experimental/ranges/functional>
Défini dans l'espace de noms std::experimental::ranges
invoque un objet Callable avec les arguments donnés
(modèle de fonction)
objet fonction implémentant x == y
(modèle de classe)
objet fonction implémentant x ! = y
(modèle de classe)
objet fonction implémentant x > y
(modèle de classe)
objet fonction implémentant x < y
(modèle de classe)
objet fonction implémentant x >= y
(modèle de classe)
objet fonction implémentant x <= y
(modèle de classe)
objet fonction qui retourne son argument inchangé
(classe)
Métaprogrammation et traits de type
Défini dans l'en-tête <experimental/ranges/type_traits>
Défini dans l'espace de noms std::experimental::ranges
vérifie si des objets d'un type peuvent être échangés avec des objets de même type ou de type différent
(modèle de classe)
déterminer le type de référence commun d'un ensemble de types
(modèle de classe)
déterminer le type commun d'un ensemble de types
(modèle de classe)
Paires et tuples étiquetés
Défini dans l'en-tête <experimental/ranges/utility>
Défini dans l'espace de noms std::experimental::ranges
spécifie qu'un type est un spécificateur de balise
(concept)
spécifie qu'un type représente un spécificateur de balise et son type d'élément
(concept)
augmente un type de type tuple avec des accesseurs nommés
(modèle de classe)
modèle d'alias pour un std::pair étiqueté
(modèle d'alias)
fonction utilitaire pour créer une tagged_pair
(modèle de fonction)
Défini dans l'en-tête <experimental/ranges/tuple>
alias template pour un tuple étiqueté std::tuple
(alias template)
fonction utilitaire pour créer un tagged_tuple
(modèle de fonction)
Défini dans l'en-tête <experimental/ranges/algorithm>
Défini dans l'espace de noms std::experimental::ranges::tag
spécificateurs de balises pour utilisation avec ranges::tagged
(classe)

Itérateurs

Défini dans l'en-tête <experimental/ranges/iterator>
Concepts liés aux itérateurs
Défini dans l'espace de noms std::experimental::ranges
Concepts des itérateurs
spécifie qu'un type est lisible en appliquant l'opérateur *
(concept)
spécifie qu'une valeur peut être écrite dans l'objet référencé par un itérateur
(concept)
spécifie qu'un type Semiregular peut être incrémenté avec les opérateurs de pré-incrémentation et post-incrémentation
(concept)
spécifie que l'opération d'incrémentation sur un type WeaklyIncrementable préserve l'égalité et que le type est EqualityComparable
(concept)
spécifie que les objets d'un type peuvent être incrémentés et déréférencés
(concept)
spécifie qu'un objet d'un type est un sentinelle pour un Iterator type
(concept)
spécifie que l'opérateur - peut être appliqué à un itérateur et un sentinelle pour calculer leur différence en temps constant
(concept)
spécifie qu'un type est un itérateur d'entrée, c'est-à-dire que ses valeurs référencées peuvent être lues et qu'il peut être pré-incrémenté et post-incrémenté
(concept)
spécifie qu'un type est un itérateur de sortie pour un type de valeur donné, c'est-à-dire que des valeurs de ce type peuvent y être écrites et qu'il peut être pré-incrémenté et post-incrémenté
(concept)
spécifie qu'un InputIterator est un itérateur avant, supportant la comparaison d'égalité et le multi-passage
(concept)
spécifie qu'un ForwardIterator est un itérateur bidirectionnel, prenant en charge le déplacement vers l'arrière
(concept)
spécifie qu'un BidirectionalIterator est un itérateur à accès aléatoire, permettant un déplacement en temps constant et l'indexation
(concept)
Concepts d'appel indirect
spécifie qu'un type appelable peut être invoqué avec le résultat de la déréférenciation d'un Readable type
(concept)
spécifie qu'un objet appelable, lorsqu'il est invoqué avec le résultat du déréférencement d'un Readable type, satisfait Predicate
(concept)
spécifie qu'un objet appelable, lorsqu'il est invoqué avec le résultat du déréférencement de certains Readable types, satisfait Relation
(concept)
spécifie qu'un objet appelable, lorsqu'il est invoqué avec le résultat du déréférencement de certains Readable types, satisfait StrictWeakOrder
(concept)
Exigences communes des algorithmes
spécifie que les valeurs peuvent être déplacées d'un Readable type vers un Writable type
(concept)
spécifie que les valeurs peuvent être déplacées d'un Readable type vers un Writable type et que le déplacement peut être effectué via un objet intermédiaire
(concept)
spécifie que les valeurs peuvent être copiées d'un Readable type vers un Writable type
(concept)
spécifie que les valeurs peuvent être copiées d'un Readable type vers un Writable type et que la copie peut être effectuée via un objet intermédiaire
(concept)
spécifie que les valeurs référencées par deux Readable types peuvent être échangées
(concept)
spécifie que les valeurs référencées par deux Readable types peuvent être comparées
(concept)
spécifie les exigences communes des algorithmes qui réorganisent les éléments sur place
(concept)
spécifie les exigences des algorithmes qui fusionnent des séquences triées en une séquence de sortie en copiant les éléments
(concept)
spécifie les exigences communes des algorithmes qui réorganisent les séquences en séquences ordonnées
(concept)
Utilitaires de concepts
calcule le résultat de l'invocation d'un objet appelable sur le résultat du déréférencement d'un ensemble de Readable types
(modèle de classe)
modèle d'assistance pour spécifier les contraintes sur les algorithmes qui acceptent des projections
(modèle de classe)
Primitives d'itérateur
Utilitaires d'itérateur
Défini dans l'espace de noms std::experimental::ranges
convertit le résultat du déréférencement d'un objet en son type de référence rvalue associé
(objet point de personnalisation)
échange les valeurs référencées par deux objets déréférençables
(objet de point de personnalisation)
Caractéristiques des itérateurs
Défini dans l'espace de noms std::experimental::ranges
obtient le type de différence d'un WeaklyIncrementable type
(modèle de classe)
obtient le type de valeur d'un Readable type
(modèle de classe)
obtient la catégorie d'itérateur d'un type d'itérateur d'entrée
(modèle de classe)
classe de traits de compatibilité qui collecte les types associés d'un itérateur
(alias de modèle)
obtient les types de référence associés à un objet déréférençable
(alias de modèle)
Étiquettes de catégorie d'itérateur
Défini dans l'espace de noms std::experimental::ranges
types de classes vides utilisés pour indiquer les catégories d'itérateurs
(classe)
std::iterator_traits spécialisations
Défini dans l'espace de noms std
spécialise std::iterator_traits pour les itérateurs du TS ranges
(spécialisation de modèle de classe)
Opérations sur les itérateurs
Défini dans l'espace de noms std::experimental::ranges
avance un itérateur d'une distance donnée
(modèle de fonction)
retourne la distance entre un itérateur et un sentinelle, ou entre le début et la fin d'une plage
(modèle de fonction)
incrémente un itérateur
(modèle de fonction)
décrémente un itérateur
(modèle de fonction)
Adaptateurs d'itérateurs
Défini dans l'espace de noms std::experimental::ranges
adaptateur d'itérateur pour le parcours en ordre inverse
(modèle de classe)
adaptateur d'itérateur pour l'insertion à la fin d'un conteneur
(modèle de classe)
adaptateur d'itérateur pour l'insertion au début d'un conteneur
(modèle de classe)
adaptateur d'itérateur pour l'insertion dans un conteneur
(modèle de classe)
adaptateur d'itérateur qui se déréférence en une référence rvalue
(modèle de classe)
adaptateur de sentinelle à utiliser avec move_iterator
(modèle de classe)
adapte une paire itérateur-sentinelle en un type d'itérateur commun pour utilisation avec des algorithmes hérités
(modèle de classe)
adaptateur d'itérateur qui garde trace de sa distance depuis sa position de départ
(modèle de classe)
type sentinelle vide à utiliser avec les types d'itérateurs qui connaissent la limite de leur plage
(classe)
enveloppe pour un itérateur potentiellement suspendu
(modèle de classe)
modèle d'alias qui encapsule le type d'itérateur d'une plage de rvalue avec dangling
(modèle d'alias)
type sentinelle utilisé avec n'importe quel itérateur pour désigner une plage infinie
(classe)
Itérateurs de flux
Défini dans l'espace de noms std::experimental::ranges
itérateur d'entrée qui lit depuis std::basic_istream
(modèle de classe)
itérateur de sortie qui écrit dans std::basic_ostream
(modèle de classe)
itérateur d'entrée qui lit depuis std::basic_streambuf
(modèle de classe)
itérateur de sortie qui écrit dans std::basic_streambuf
(modèle de classe)

Intervalles

Défini dans l'en-tête <experimental/ranges/range>
Concepts de range
spécifie qu'un type est un range, c'est-à-dire qu'il fournit un itérateur begin et un sentinelle end
(concept)
spécifie qu'un range connaît sa taille en temps constant
(concept)
spécifie qu'un range est une vue, c'est-à-dire qu'il a une copie/déplacement/affectation en temps constant
(concept)
spécifie qu'un range a des types d'itérateur et de sentinelle identiques
(concept)
spécifie un range dont le type d'itérateur satisfait InputIterator
(concept)
spécifie un range dont le type d'itérateur satisfait OutputIterator
(concept)
spécifie un range dont le type d'itérateur satisfait ForwardIterator
(concept)
spécifie un range dont le type d'itérateur satisfait BidirectionalIterator
(concept)
spécifie un range dont le type d'itérateur satisfait RandomAccessIterator
(concept)
Accès au range
Défini dans l'espace de noms std::experimental::ranges
retourne un itérateur vers le début d'un range
(objet de point de personnalisation)
retourne un itérateur vers la fin d'un range
(objet de point de personnalisation)
retourne un itérateur inverse vers un range
(objet de point de personnalisation)
retourne un itérateur inverse de fin vers un range
(objet de point de personnalisation)
Primitives de range
Défini dans l'espace de noms std::experimental::ranges
obtient la taille d'un range dont la taille peut être calculée en temps constant
(objet de point de personnalisation)
vérifie si un range est vide
(objet de point de personnalisation)
obtient un pointeur vers le début d'un range contigu
(objet de point de personnalisation)
obtient les types d'itérateur et de sentinelle d'un range
(alias de modèle)

Algorithmes

Défini dans l'en-tête <experimental/ranges/algorithm>
Opérations de séquence non modifiantes
Défini dans l'espace de noms std::experimental::ranges
vérifie si un prédicat est true pour tous, au moins un ou aucun des éléments d'un intervalle
(modèle de fonction)
applique une fonction à une plage d'éléments
(modèle de fonction)
retourne le nombre d'éléments satisfaisant des critères spécifiques
(modèle de fonction)
trouve la première position où deux plages diffèrent
(modèle de fonction)
détermine si deux ensembles d'éléments sont identiques
(modèle de fonction)
retourne true si une plage est lexicographiquement inférieure à une autre
(modèle de fonction)
trouve le premier élément satisfaisant des critères spécifiques
(modèle de fonction)
trouve la dernière séquence d'éléments dans une certaine plage
(modèle de fonction)
recherche l'un quelconque d'un ensemble d'éléments
(modèle de fonction)
trouve les deux premiers éléments adjacents qui sont égaux (ou qui satisfont un prédicat donné)
(modèle de fonction)
recherche une plage d'éléments
(modèle de fonction)
recherche un nombre d'occurrences consécutives d'un élément dans une plage
(modèle de fonction)
Opérations de modification de séquence
Défini dans l'espace de noms std::experimental::ranges
copie une plage d'éléments vers un nouvel emplacement
(modèle de fonction)
copie un certain nombre d'éléments vers un nouvel emplacement
(modèle de fonction)
copie une plage d'éléments dans l'ordre inverse
(modèle de fonction)
déplace une plage d'éléments vers un nouvel emplacement
(modèle de fonction)
déplace une plage d'éléments vers un nouvel emplacement dans l'ordre inverse
(modèle de fonction)
assigne une valeur à une plage d'éléments
(modèle de fonction)
attribue une valeur à un certain nombre d'éléments
(modèle de fonction)
applique une fonction à une plage d'éléments
(modèle de fonction)
enregistre le résultat d'une fonction dans une plage
(modèle de fonction)
sauvegarde le résultat de N applications d'une fonction
(modèle de fonction)
supprime les éléments satisfaisant des critères spécifiques
(modèle de fonction)
copie une plage d'éléments en omettant ceux qui satisfont des critères spécifiques
(modèle de fonction)
remplace toutes les valeurs satisfaisant des critères spécifiques par une autre valeur
(modèle de fonction)
copie une plage, en remplaçant les éléments satisfaisant des critères spécifiques par une autre valeur
(modèle de fonction)
échange deux plages d'éléments
(modèle de fonction)
inverse l'ordre des éléments dans une plage
(modèle de fonction)
crée une copie d'une plage qui est inversée
(modèle de fonction)
fait pivoter l'ordre des éléments dans une plage
(modèle de fonction)
copie et fait pivoter une plage d'éléments
(modèle de fonction)
réorganise aléatoirement les éléments dans une plage
(modèle de fonction)
supprime les éléments dupliqués consécutifs dans une plage
(modèle de fonction)
crée une copie d'une plage d'éléments qui ne contient pas de doublons consécutifs
(modèle de fonction)
Opérations de partitionnement
Défini dans l'espace de noms std::experimental::ranges
détermine si la plage est partitionnée par le prédicat donné
(modèle de fonction)
divise une plage d'éléments en deux groupes
(modèle de fonction)
copie une plage en divisant les éléments en deux groupes
(modèle de fonction)
divise les éléments en deux groupes tout en préservant leur ordre relatif
(modèle de fonction)
localise le point de partition d'une plage partitionnée
(modèle de fonction)
Opérations de tri
Défini dans l'espace de noms std::experimental::ranges
vérifie si une plage est triée par ordre croissant
(modèle de fonction)
trouve la plus grande sous-plage triée
(modèle de fonction)
trie une plage en ordre croissant
(modèle de fonction)
trie les N premiers éléments d'une plage
(modèle de fonction)
copie et trie partiellement une plage d'éléments
(modèle de fonction)
trie une plage d'éléments en préservant l'ordre entre les éléments égaux
(modèle de fonction)
trie partiellement la plage donnée en s'assurant qu'elle est partitionnée par l'élément donné
(modèle de fonction)
Opérations de recherche binaire (sur des plages triées)
Défini dans l'espace de noms std::experimental::ranges
retourne un itérateur vers le premier élément non inférieur à la valeur donnée
(modèle de fonction)
retourne un itérateur vers le premier élément supérieur à une certaine valeur
(modèle de fonction)
détermine si un élément existe dans une certaine plage
(modèle de fonction)
retourne la plage d'éléments correspondant à une clé spécifique
(modèle de fonction)
Opérations sur les ensembles (sur des plages triées)
Défini dans l'espace de noms std::experimental::ranges
fusionne deux plages triées
(modèle de fonction)
fusionne deux plages ordonnées en place
(modèle de fonction)
renvoie true si un ensemble est un sous-ensemble d'un autre
(modèle de fonction)
calcule la différence entre deux ensembles
(modèle de fonction)
calcule l'intersection de deux ensembles
(modèle de fonction)
calcule la différence symétrique entre deux ensembles
(modèle de fonction)
calcule l'union de deux ensembles
(modèle de fonction)
Opérations sur le tas
Défini dans l'espace de noms std::experimental::ranges
vérifie si la plage donnée est un tas maximum
(modèle de fonction)
trouve le plus grand sous-intervalle qui est un tas maximum
(modèle de fonction)
crée un tas maximal à partir d'une plage d'éléments
(modèle de fonction)
ajoute un élément à un tas maximum
(modèle de fonction)
supprime le plus grand élément d'un tas maximum
(modèle de fonction)
transforme un tas maximal en une plage d'éléments triés par ordre croissant
(modèle de fonction)
Opérations minimum/maximum
Défini dans l'espace de noms std::experimental::ranges
renvoie la plus grande des valeurs données
(modèle de fonction)
renvoie le plus grand élément dans une plage
(modèle de fonction)
renvoie la plus petite des valeurs données
(modèle de fonction)
renvoie le plus petit élément dans une plage
(modèle de fonction)
retourne le plus petit et le plus grand de deux éléments
(modèle de fonction)
retourne les plus petits et les plus grands éléments dans une plage
(modèle de fonction)
Opérations de permutation
Défini dans l'espace de noms std::experimental::ranges
détermine si une séquence est une permutation d'une autre séquence
(modèle de fonction)
génère la prochaine permutation lexicographique supérieure d'une plage d'éléments
(modèle de fonction)
génère la permutation lexicographique suivante plus petite d'une plage d'éléments
(modèle de fonction)