std:: contiguous_iterator

Défini dans l'en-tête <iterator>
template < class I > concept contiguous_iterator = std:: random_access_iterator < I > && std:: derived_from < /*ITER_CONCEPT*/ < I > , std:: contiguous_iterator_tag > && std:: is_lvalue_reference_v < std:: iter_reference_t < I >> && std:: same_as < std:: iter_value_t < I > , std:: remove_cvref_t < std:: iter_reference_t < I >>> && requires ( const I & i ) { { std:: to_address ( i ) } - > std:: same_as < std:: add_pointer_t < std:: iter_reference_t < I >>> ; } ;		(depuis C++20)

Le concept contiguous_iterator affine random_access_iterator en fournissant la garantie que les éléments désignés sont stockés de manière contiguë en mémoire.

Étant donné un itérateur i d'un type qui modélise contiguous_iterator , un sentinelle s et un entier non négatif n : Pour toute plage [ i , s ) , les fonctions de la bibliothèque standard peuvent la remplacer par [ std:: to_address ( i ) , std:: to_address ( i + ranges:: distance ( i, s ) ) ) . Pour toute plage i + [ ​ 0 ​ , n ) , les fonctions de la bibliothèque standard peuvent la remplacer par std:: to_address ( i ) + [ ​ 0 ​ , std:: to_address ( i + n ) ) . Cela signifie qu'un programme ne peut pas compter sur les effets secondaires du déréférencement, de l'incrémentation ou de la décrémentation d'un itérateur contigu i , car les fonctions de la bibliothèque standard peuvent opérer sur des pointeurs obtenus par std:: to_address ( i ) au lieu d'opérer directement sur i .

(depuis C++26)

Table des matières 1 Détermination du concept d'itérateur 2 Exigences sémantiques 3 Préservation de l'égalité 4 Variations d'expressions implicites 5 Notes 6 Rapports de défauts 7 Voir aussi

Détermination du concept d'itérateur

La définition de ce concept est spécifiée via un alias template d'exposition uniquement /*ITER_CONCEPT*/ .

Afin de déterminer /*ITER_CONCEPT*/ < I > , soit ITER_TRAITS < I > dénotant I si la spécialisation std:: iterator_traits < I > est générée à partir du modèle primaire, ou std:: iterator_traits < I > sinon :

• Si ITER_TRAITS < I > :: iterator_concept est valide et désigne un type, /*ITER_CONCEPT*/ < I > dénote ce type.
• Sinon, si ITER_TRAITS < I > :: iterator_category est valide et désigne un type, /*ITER_CONCEPT*/ < I > dénote ce type.
• Sinon, si std:: iterator_traits < I > est généré à partir du modèle primaire, /*ITER_CONCEPT*/ < I > dénote std::random_access_iterator_tag .
  (C'est-à-dire que std:: derived_from < /*ITER_CONCEPT*/ < I > , std:: contiguous_iterator_tag > est supposé être false .)
• Sinon, /*ITER_CONCEPT*/ < I > ne dénote pas un type et entraîne un échec de substitution.

Exigences sémantiques

Soient a et b des itérateurs déréférençables et c un itérateur non déréférençable de type I tels que b soit accessible depuis a et c soit accessible depuis b , le type I modélise contiguous_iterator seulement si tous les concepts qu'il subsume sont modélisés et si toutes les conditions suivantes sont satisfaites :

• std:: to_address ( a ) == std:: addressof ( * a ) .
• std:: to_address ( b ) == std:: to_address ( a ) + std:: iter_difference_t < I > ( b - a ) .
• std:: to_address ( c ) == std:: to_address ( a ) + std:: iter_difference_t < I > ( c - a ) .
• std:: to_address ( I { } ) est bien défini.
• ranges:: iter_move ( a ) a le même type, la même catégorie de valeur et les mêmes effets que std :: move ( * a ) .
• Si ranges:: iter_swap ( a, b ) est bien formé, il a des effets équivalents à ranges:: swap ( * a, * b ) .

Préservation de l'égalité

Les expressions déclarées dans les requires expressions des concepts de la bibliothèque standard doivent être equality-preserving (sauf indication contraire).

Variations d'expression implicite

Une requires expression qui utilise une expression non modifiante pour un opérande constant lvalue requiert également les variations d'expression implicites .

Notes

contiguous_iterator est modélisé par chaque type de pointeur vers un type d'objet complet.

Les types d'itérateurs dans la bibliothèque standard qui doivent satisfaire les exigences LegacyContiguousIterator en C++17 doivent également modéliser contiguous_iterator en C++20.

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	S'applique à	Comportement publié	Comportement corrigé
LWG 3607	C++20	contiguous_iterator pourrait avoir des comportements personnalisés ranges::iter_move et ranges::iter_swap	interdit
LWG 4170	C++20	une paire d'itérateurs contiguous_iterator initialisés par valeur pourrait ne pas pouvoir représenter une plage vide	garanti

Voir aussi

random_access_iterator (C++20)

spécifie qu'un bidirectional_iterator est un itérateur à accès aléatoire, prenant en charge l'avancement en temps constant et l'indexation (concept)