Namespaces
Variants

Ranges library (since C++20)

From cppreference.net
C++
Ranges library
Range adaptors

La bibliothèque de plages est une extension et une généralisation des bibliothèques d'algorithmes et d'itérateurs qui les rend plus puissantes en les rendant composables et moins sujettes aux erreurs.

La bibliothèque crée et manipule des vues de plages, des objets légers qui représentent indirectement des séquences itérables ( plages ). Les plages sont une abstraction au-dessus de

  • [ début , fin ) – paires d'itérateurs, par exemple des plages créées par conversion implicite depuis des conteneurs. Tous les algorithmes qui prennent des paires d'itérateurs ont maintenant des surcharges qui acceptent des plages (par exemple ranges::sort )
  • début + [ ​ 0 ​ , taille ) – séquences comptées, par exemple la plage retournée par views::counted
  • [ début , prédicat ) – séquences à terminaison conditionnelle, par exemple la plage retournée par views::take_while
  • [ début , .. ) – séquences non bornées, par exemple la plage retournée par views::iota

La bibliothèque de plages inclut les algorithmes de plages , qui sont appliqués aux plages de manière immédiate, et les adaptateurs de plages , qui sont appliqués aux vues de manière paresseuse. Les adaptateurs peuvent être composés en pipelines, de sorte que leurs actions se produisent lors de l'itération de la vue.

Défini dans l'en-tête <ranges>
namespace std {

namespace views = ranges :: views ;

}
(depuis C++20)

L'alias d'espace de noms std::views est fourni comme raccourci pour std::ranges::views .

Défini dans l'espace de noms std::ranges

Table des matières

Accès aux plages
Défini dans l'en-tête <ranges>
Défini dans l'en-tête <iterator>
(C++20)
retourne un itérateur vers le début d'un intervalle
(objet de point de personnalisation)
(C++20)
retourne un sentinelle indiquant la fin d'une plage
(objet de point de personnalisation)
(C++20)
retourne un itérateur vers le début d'une plage en lecture seule
(objet de point de personnalisation)
(C++20)
retourne un sentinelle indiquant la fin d'une plage en lecture seule
(objet de point de personnalisation)
(C++20)
retourne un itérateur inverse vers un intervalle
(objet de point de personnalisation)
(C++20)
retourne un itérateur de fin inverse pour une plage
(objet de point de personnalisation)
(C++20)
retourne un itérateur inverse vers une plage en lecture seule
(objet de point de personnalisation)
(C++20)
retourne un itérateur de fin inverse vers une plage en lecture seule
(objet de point de personnalisation)
(C++26)
retourne un entier égal à l'indication de réserve fournie par un intervalle
(objet point de personnalisation)
(C++20)
retourne un entier égal à la taille d'un intervalle
(objet de point de personnalisation)
(C++20)
retourne un entier signé égal à la taille d'un intervalle
(objet point de personnalisation)
(C++20)
vérifie si une plage est vide
(objet de point de personnalisation)
(C++20)
obtient un pointeur vers le début d'une plage contiguë
(objet de point de personnalisation)
(C++20)
obtient un pointeur vers le début d'une plage contiguë en lecture seule
(objet de point de personnalisation)
Primitives de plage
Défini dans l'en-tête <ranges>
(C++20) (C++23) (C++20) (C++23)
obtient les types d'itérateur et de sentinelle d'une plage
(alias de modèle)
(C++20) (C++20) (C++20)
obtient les types de taille, différence et valeur d'une plage
(modèle d'alias)
(C++20) (C++23) (C++20) (C++20)
obtient les types de référence d'une plage
(modèle d'alias)
Gestion des itérateurs pendants
Défini dans l'en-tête <ranges>
(C++20)
un type de substitution indiquant qu'un itérateur ou un subrange ne devrait pas être retourné car il serait suspendu
(classe)
(C++20)
obtient le type d'itérateur ou subrange d'un borrowed_range
(alias de modèle)
Autres utilitaires
Défini dans l'en-tête <ranges>
(C++23)
étiquette une plage pour être traitée comme une séquence plutôt qu'une valeur unique
(modèle de classe)
Concepts de plage
Défini dans l'en-tête <ranges>
(C++20)
spécifie qu'un type est une plage, c'est-à-dire qu'il fournit un itérateur begin et un sentinelle end
(concept)
(C++20)
spécifie qu'un type est une range et que les itérateurs obtenus à partir d'une expression de celui-ci peuvent être retournés sans risque de pendaison
(concept)
(C++26)
spécifie qu'une plage peut estimer sa taille en temps constant
(concept)
(C++20)
spécifie qu'une gamme connaît sa taille en temps constant
(concept)
(C++20)
spécifie qu'une plage est une vue, c'est-à-dire qu'elle possède des opérations de copie/déplacement/assignation en temps constant
(concept)
(C++20)
spécifie une gamme dont le type d'itérateur satisfait input_iterator
(concept)
(C++20)
spécifie une gamme dont le type d'itérateur satisfait output_iterator
(concept)
(C++20)
spécifie une plage dont le type d'itérateur satisfait forward_iterator
(concept)
(C++20)
spécifie une gamme dont le type d'itérateur satisfait bidirectional_iterator
(concept)
(C++20)
spécifie une plage dont le type d'itérateur satisfait random_access_iterator
(concept)
(C++20)
spécifie une gamme dont le type d'itérateur satisfait contiguous_iterator
(concept)
(C++20)
spécifie qu'un range a des types d'itérateur et de sentinelle identiques
(concept)
(C++20)
spécifie les exigences pour qu'un range puisse être converti de manière sûre en une view
(concept)
(C++23)
spécifie qu'une plage possède des éléments en lecture seule
(concept)
Conversions de plage
Défini dans l'en-tête <ranges>
(C++23)
construit un nouvel objet non-vue à partir d'une plage d'entrée
(modèle de fonction)
Vues
Défini dans l'en-tête <ranges>
(C++20)
classe modèle utilitaire pour définir une view , utilisant le modèle de conception curieusement récurrent
(classe modèle)
(C++20)
combine une paire itérateur-sentinelle en une view
(modèle de classe)

Usines de plages

Défini dans l'en-tête <ranges>
Défini dans l'espace de noms std::ranges
(C++20)
une view vide sans éléments
(modèle de classe) (modèle de variable)
(C++20)
une view qui contient un seul élément d'une valeur spécifiée
(modèle de classe) (objet de point de personnalisation)
(C++20)
une view constituée d'une séquence générée en incrémentant répétitivement une valeur initiale
(modèle de classe) (objet de point de personnalisation)
(C++23)
une view constituée d'une séquence générée en produisant répétitivement la même valeur
(modèle de classe) (objet de point de personnalisation)
(C++20)
une view constituée des éléments obtenus par l'application successive de operator>> sur le flux d'entrée associé
(modèle de classe) (objet de point de personnalisation)

Adaptateurs de plages

Défini dans l'en-tête <ranges>
Défini dans l'espace de noms std::ranges
(C++23)
classe de base d'assistance pour définir un objet de fermeture d'adaptateur de plage
(modèle de classe)
(C++20)
une view qui inclut tous les éléments d'une range
(alias de modèle) (objet adaptateur de plage)
(C++20)
une view des éléments d'une autre range
(modèle de classe)
(C++20)
une view avec propriété exclusive d'une certaine range
(modèle de classe)
(C++23)
une view d'une séquence qui convertit chaque élément en une rvalue
(modèle de classe) (objet adaptateur de gamme)
(C++20)
une view qui consiste en les éléments d'un range qui satisfait un prédicat
(modèle de classe) (objet adaptateur de gamme)
(C++20)
une view d'une séquence qui applique une fonction de transformation à chaque élément
(modèle de classe) (objet adaptateur de gamme)
(C++20)
une view composée des N premiers éléments d'une autre view
(modèle de classe) (objet adaptateur de gamme)
(C++20)
une view composée des éléments initiaux d'une autre view , jusqu'au premier élément pour lequel un prédicat retourne false
(modèle de classe) (objet adaptateur de gamme)
(C++20)
une view composée d'éléments d'une autre view , ignorant les N premiers éléments
(modèle de classe) (objet adaptateur de gamme)
(C++20)
une view constituée des éléments d'une autre view , ignorant la sous-séquence initiale des éléments jusqu'au premier élément où le prédicat retourne false
(modèle de classe) (objet adaptateur de gamme)
(C++20)
une view constituée de la séquence obtenue par l'aplatissement d'une view de range s
(modèle de classe) (objet adaptateur de gamme)
(C++23)
une view constituée de la séquence obtenue en aplatissant une vue de gammes, avec le délimiteur entre les éléments
(modèle de classe) (objet adaptateur de gamme)
(C++20)
une view sur les sous-intervalles obtenus en divisant une autre view en utilisant un délimiteur
(modèle de classe) (objet adaptateur de plage)
(C++20)
une view sur les sous-intervalles obtenus en divisant une autre view en utilisant un délimiteur
(modèle de classe) (objet adaptateur de gamme)
(C++26)
une view constituée de la concaténation des vues adaptées
(modèle de classe) (objet de point de personnalisation)
(C++20)
crée un sous-intervalle à partir d'un itérateur et d'un compteur
(objet de point de personnalisation)
(C++20)
convertit une view en une common_range
(modèle de classe) (objet adaptateur de gamme)
(C++20)
une view qui itère sur les éléments d'une autre vue bidirectionnelle en ordre inverse
(modèle de classe) (objet adaptateur de gamme)
(C++23)
convertit une view en une constant_range
(modèle de classe) (objet adaptateur de plage)
(C++20)
prend une view constituée de valeurs tuple-like et un nombre N, et produit une view du N ème élément de chaque tuple
(modèle de classe) (objet adaptateur de gamme)
(C++20)
prend une view constituée de valeurs de type paire et produit une view des premiers éléments de chaque paire
(modèle de classe) (objet adaptateur de gamme)
(C++20)
prend une view constituée de valeurs de type paire et produit une view des seconds éléments de chaque paire
(modèle de classe) (objet adaptateur de plage)
(C++23)
une view qui associe chaque élément de la séquence adaptée à un tuple contenant à la fois la position de l'élément et sa valeur
(modèle de classe) (objet adaptateur de gamme)
(C++23)
une view constituée de tuples de références aux éléments correspondants des vues adaptées
(modèle de classe) (objet de point de personnalisation)
(C++23)
une view constituée des résultats de l'application d'une fonction de transformation aux éléments correspondants des vues adaptées
(modèle de classe) (objet de point de personnalisation)
(C++23)
une view constituée de tuples de références aux éléments adjacents de la vue adaptée
(modèle de classe) (objet adaptateur de plage)
(C++23)
une view constituée des résultats de l'application d'une fonction de transformation aux éléments adjacents de la vue adaptée
(modèle de classe) (objet adaptateur de plage)
(C++23)
une plage de view s qui sont des segments successifs non chevauchants de taille N des éléments d'une autre view
(modèle de classe) (objet adaptateur de plage)
(C++23)
une view dont le M ième élément est une view sur les M ième à (M + N - 1) ième éléments d'une autre view
(modèle de classe) (objet adaptateur de gamme)
(C++23)
divise la view en sous-intervalles entre chaque paire d'éléments adjacents pour lesquels le prédicat donné retourne false
(modèle de classe) (objet adaptateur de gamme)
(C++23)
une view constituée d'éléments d'une autre view , avançant de N éléments à la fois
(modèle de classe) (objet adaptateur de plage)
(C++23)
une view constituée de tuples de résultats calculés par le produit cartésien n-aire des vues adaptées
(modèle de classe) (objet de point de personnalisation)
(C++26)
une view qui met en cache le dernier élément accédé de sa séquence sous-jacente
(modèle de classe) (objet adaptateur de plage)
(C++26)
convertit une view en une plage qui est input_range -uniquement et non- common_range
(modèle de classe) (objet adaptateur de plage)

Générateurs de plage (depuis C++23)

Défini dans l'en-tête <generator>
Défini dans l'espace de noms std
(C++23)
Une view qui représente un générateur synchrone de coroutine
(modèle de classe)

Éléments d'assistance

Objets adaptateurs de plage

Voir RangeAdaptorObject (RAO).

Objets de fermeture d'adaptateur de plage

Voir RangeAdaptorClosureObject (RACO).

Objets de point de personnalisation

Voir Customization point object (CPO).

Enveloppe assignable

Certains adaptateurs de plage enveloppent leurs éléments ou objets de fonction avec le copyable-box (jusqu'à C++23) movable-box (depuis C++23) . L'enveloppe améliore l'objet encapsulé avec l'assignabilité lorsque nécessaire.

Cache non propagateur

Certains adaptateurs de plages sont spécifiés en termes d'un modèle de classe d'exposition uniquement non-propagating-cache , qui se comporte presque comme std:: optional < T > (voir la description pour les différences).

Type conditionnellement const

template < bool Const, class T >
using /*maybe-const*/ = std:: conditional_t < Const, const T, T > ;
( exposition uniquement* )

Le modèle d'alias /*maybe-const*/ est un raccourci utilisé pour appliquer conditionnellement un qualificatif const au type T .

Modèles d'assistance pour les types de type entier

template < /*is-integer-like*/ T >
using /*make-signed-like-t*/ < T > = /* voir description */ ;
(1) ( exposition uniquement* )
template < /*is-integer-like*/ T >
using /*make-unsigned-like-t*/ < T > = /* voir description */ ;
(2) ( exposition uniquement* )
template < /*is-integer-like*/ T >

/*make-unsigned-like-t*/ < T > /*to-unsigned-like*/ ( T t )
{
return static_cast < /*make-unsigned-like-t*/ < T >> ( t ) ;

}
(3) ( exposition uniquement* )
1) Pour un type de type entier T :
  • Si T est un type entier, /*make-signed-like-t*/ < T > est std:: make_signed_t < T > .
  • Sinon, /*make-signed-like-t*/ < T > est un type signé non spécifié correspondant de même largeur que T .
2) Pour un type de type entier T :
  • Si T est un type entier, /*make-unsigned-like-t*/ < T > est std:: make_unsigned_t < T > .
  • Sinon, /*make-signed-like-t*/ < T > est un type non signé de type entier non spécifié correspondant, de même largeur que T .
3) Convertit explicitement t en /*make-unsigned-like-t*/ < T > .

Aides aux objets de point de personnalisation

template < ranges:: input_range R >

constexpr auto & /*possibly-const-range*/ ( R & r ) noexcept
{
if constexpr ( ranges:: input_range < const R > )
return const_cast < const R & > ( r ) ;
else
return r ;

}
(1) ( exposition uniquement* )
template < class T >

constexpr auto /*as-const-pointer*/ ( const T * p ) noexcept
{
return p ;

}
(2) ( exposition uniquement* )

Certains objets de point de personnalisation d'accès aux plages sont spécifiés en termes de ces modèles de fonctions uniquement à titre d'exposition.

1) /*possibly-const-range*/ retourne la version qualifiée const de r si const R modélise input_range ; sinon, retourne r sans aucun transtypage.
2) /*as-const-pointer*/ retourne un pointeur vers un objet de type constant.

Aides d'adaptateur de plage

template < class F, class Tuple >

constexpr auto /*tuple-transform*/ ( F && f, Tuple && tuple )
{
return std:: apply ( [ & ] < class ... Ts > ( Ts && ... args )
{
return std:: tuple < std:: invoke_result_t < F & , Ts > ... >
( std:: invoke ( f, std:: forward < Ts > ( args ) ) ... ) ;
} , std:: forward < Tuple > ( tuple ) ) ;

}
(1) ( exposition uniquement* )
template < class F, class Tuple >

constexpr void /*parcours-tuple*/ ( F && f, Tuple && tuple )
{
std:: apply ( [ & ] < class ... Ts > ( Ts && ... args )
{
( static_cast < void > ( std:: invoke ( f, std:: forward < Ts > ( args ) ) ) , ... ) ;
} , std:: forward < Tuple > ( tuple ) ) ;

}
(2) ( exposition uniquement* )
template < class T >

constexpr T & /*as-lvalue*/ ( T && t )
{
return static_cast < T & > ( t ) ;

}
(3) ( exposition uniquement* )

Certains adaptateurs de plages sont spécifiés en termes de ces modèles de fonctions d'exposition uniquement.

1) /*tuple-transform*/ retourne un nouveau tuple construit en appliquant f à chaque élément de tuple .
2) /*tuple-for-each*/ applique f à chaque élément du tuple et ne retourne rien.
3) /*as-lvalue*/ transmet la rvalue t comme lvalue.

Concepts d'assistance

Les concepts suivants, à titre d'exposition uniquement, sont utilisés pour plusieurs types, mais ils ne font pas partie de l'interface de la bibliothèque standard.

template < class R >

concept /*vue-simple*/ =
ranges:: view < R > && ranges:: range < const R > &&
std:: same_as < ranges:: iterator_t < R > , ranges:: iterator_t < const R >> &&

std:: same_as < ranges:: sentinel_t < R > , ranges:: sentinel_t < const R >> ;
(1) ( exposition uniquement* )
template < class I >

concept /*has-arrow*/ =
ranges :: input_iterator < I > &&

( std:: is_pointer_v < I > || requires ( const I i ) { i. operator - > ( ) ; } ) ;
(2) ( exposition uniquement* )
template < class T, class U >

concept /*different-from*/ =

! std:: same_as < std:: remove_cvref_t < T > , std:: remove_cvref_t < U >> ;
(3) ( exposition uniquement* )
template < class R >

concept /*plage-avec-références-déplaçables*/ =
ranges:: input_range < R > &&
std:: move_constructible < ranges:: range_reference_t < R >> &&

std:: move_constructible < ranges:: range_rvalue_reference_t < R >> ;
(4) ( exposition uniquement* )
template < bool C, class ... Views >

concept /*tous-accès-aléatoire*/ =
( ranges:: random_access_range

< std:: conditional_t < C, const Views, Views >> && ... ) ;
(5) ( exposition uniquement* )
template < bool C, class ... Views >

concept /*all-bidirectional*/ =
( ranges:: bidirectional_range

< std:: conditional_t < C, const Views, Views >> && ... ) ;
(6) ( exposition uniquement* )
template < bool C, class ... Views >

concept /*tous-avant*/ =
( ranges:: forward_range

< std:: conditional_t < C, const Views, Views >> && ... ) ;
(7) ( exposition uniquement* )

Notes

**Note:** Aucun texte n'a été traduit car : - Les balises HTML et leurs attributs doivent être préservés - Le contenu des balises ` ` n'est pas traduit - Les termes spécifiques au C++ ne sont pas traduits - Il n'y avait aucun texte libre en dehors des éléments techniques à traduire en français
Macro de test de fonctionnalité Valeur Norme Fonctionnalité
__cpp_lib_generator 202207L (C++23) std:: generator – générateur de coroutine synchrone pour les plages
__cpp_lib_ranges 201911L (C++20) Bibliothèque de plages et algorithmes contraints
202106L (C++23)
(DR20) 		Vues non initialisables par défaut views
202110L (C++23)
(DR20) 		Vues avec propriété
202202L (C++23) ranges:: range_adaptor_closure
202207L (C++23) Assouplissement des adaptateurs de plages pour permettre les types non copiables
202211L (C++23) Suppression des surcharges "poison pills" (P2602) dans ranges:: begin etc
202302L (C++23) Assouplissement des plages pour autoriser certaines projections
202406L (C++26)
(DR20) 		Suppression de l'exigence de référence commune des concepts indirectement invocables
__cpp_lib_ranges_as_const 202207L (C++23) std:: const_iterator , ranges:: as_const_view
__cpp_lib_ranges_as_rvalue 202207L (C++23) ranges:: as_rvalue_view
__cpp_lib_ranges_cache_latest 202411L (C++26) ranges :: cache_latest_view
__cpp_lib_ranges_cartesian_product 202207L (C++23) ranges:: cartesian_product_view
__cpp_lib_ranges_chunk 202202L (C++23) ranges:: chunk_view
__cpp_lib_ranges_chunk_by 202202L (C++23) ranges:: chunk_by_view
__cpp_lib_ranges_concat 202403L (C++26) ranges:: concat_view
__cpp_lib_ranges_enumerate 202302L (C++23) ranges :: enumerate_view
__cpp_lib_ranges_join_with 202202L (C++23) ranges:: join_with_view
__cpp_lib_ranges_repeat 202207L (C++23) ranges:: repeat_view
__cpp_lib_ranges_reserve_hint 202502L (C++26) ranges :: reserve_hint et ranges :: approximately_sized_range
__cpp_lib_ranges_slide 202202L (C++23) ranges:: slide_view
__cpp_lib_ranges_stride 202207L (C++23) ranges:: stride_view
__cpp_lib_ranges_to_container 202202L (C++23) ranges:: to
__cpp_lib_ranges_to_input 202502L (C++26) ranges :: to_input_view
__cpp_lib_ranges_zip 202110L (C++23) ranges:: zip_view ,
ranges:: zip_transform_view ,
ranges:: adjacent_view ,
ranges:: adjacent_transform_view

Exemple

Exécuter ce code 
#include <iostream>
#include <ranges>
int main()
{
    auto const ints = {0, 1, 2, 3, 4, 5};
    auto even = [](int i) { return 0 == i % 2; };
    auto square = [](int i) { return i * i; };
    // la syntaxe "pipe" pour composer les vues :
    for (int i : ints | std::views::filter(even) | std::views::transform(square))
        std::cout << i << ' ';
    std::cout << '\n';
    // une syntaxe de composition "fonctionnelle" traditionnelle :
    for (int i : std::views::transform(std::views::filter(ints, even), square))
        std::cout << i << ' ';
}

Sortie : 

0 4 16
0 4 16

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 Applicable à Comportement publié Comportement corrigé
LWG 3509
( P2281R1 ) 		C++20 il n'était pas clair comment les objets adaptateurs de plage liaient les arguments de queue ils sont liés
par valeur
LWG 3948 C++23 possibly-const-range et as-const-pointer
n'étaient pas déclarés noexcept 		déclarés noexcept
LWG 4027 C++23 possibly-const-range n'ajoutait pas de qualification const
pour les plages qui modélisaient déjà constant_range 		ajoute la qualification const
pour ces plages
LWG 4112 C++20 has-arrow n'exigeait pas que i soit const-qualifié exige

Voir aussi