Namespaces
Variants

C++ named requirements: LegacyForwardIterator

From cppreference.net
C++
C++ named requirements

Un LegacyForwardIterator est un LegacyIterator qui peut lire les données de l'élément pointé.

Contrairement à LegacyInputIterator et LegacyOutputIterator , il peut être utilisé dans des algorithmes multipasses.

Si un LegacyForwardIterator it provient d'un Container , alors le type de valeur de it est le même que celui du conteneur, donc le déréférencement ( * it ) donne le type de valeur du conteneur.

Table des matières

Exigences

Type Définition
X Un type d'itérateur avant
T Le type de valeur de X (c'est-à-dire std:: iterator_traits < X > :: value_type )
Ref std:: iterator_traits < X > :: reference
Valeur Définition
i , j Valeurs de type X ou const X
r Une valeur de type X&

X satisfait LegacyForwardIterator si toutes les conditions suivantes sont satisfaites :

  • X satisfait LegacyInputIterator .
  • X satisfait DefaultConstructible .
  • Si X est un itérateur mutable , Ref est une référence vers T .
  • Si X est un itérateur constant, Ref est une référence vers const T .
  • Les objets du type X fournissent la garantie multi-pass .
  • Si i et j sont égaux, alors soit i et j sont tous deux déréférençables , soit aucun ne l'est.
  • Si i et j sont tous deux déréférençables, alors i == j si et seulement si * i et * j sont liés au même objet.
  • Les expressions suivantes doivent être valides et avoir leurs effets spécifiés :
Expression Type Effets
r ++ convertible en const X & Équivalent à X x = r ;
++ r ;
return x ; .
* i ++ Ref

Domaine d'égalité

Le domaine de == pour les itérateurs forward est celui des itérateurs sur la même séquence sous-jacente .

Cependant, les itérateurs forward initialisés par valeur peuvent être comparés, et doivent être égaux à d'autres itérateurs initialisés par valeur du même type.

En d'autres termes, les itérateurs forward initialisés par valeur se comportent comme s'ils référençaient au-delà de la fin de la même séquence vide.

(depuis C++14)

Garantie multi-passes

Deux itérateurs déréférençables a et b de type X offrent la garantie multi-pass si toutes les conditions suivantes sont satisfaites :

  • a == b implique ++ a == ++ b .
  • L'une des conditions suivantes est satisfaite :
  • X est un type pointeur.
  • L'expression ( void ) ++ X ( a ) , * a est équivalente à l'expression * a .

Concept

Pour la définition de std::iterator_traits , le concept suivant (à titre d'exposition uniquement) est défini.

template < class It >

concept __LegacyForwardIterator =
__LegacyInputIterator < It > && std:: constructible_from < It > &&
std:: is_reference_v < std:: iter_reference_t < It >> &&
std:: same_as <
std:: remove_cvref_t < std:: iter_reference_t < It >> ,
typename std:: indirectly_readable_traits < It > :: value_type > &&
requires ( It it ) {
{ it ++ } - > std:: convertible_to < const It & > ;
{ * it ++ } - > std:: same_as < std:: iter_reference_t < It >> ;

} ;

où le concept à titre d'exposition uniquement __LegacyInputIterator<T> est décrit dans LegacyInputIterator .

(depuis C++20)

Notes

Contrairement au concept std::forward_iterator , les exigences LegacyForwardIterator nécessitent que le déréférencement retourne une référence.

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 1212
( N3066 ) 		C++98 le type de * i ++ ne correspondait pas au type de
* i -- requis par LegacyBidirectionalIterator 		modifié le
type en Ref
LWG 1311
( N3066 ) 		C++98 « a == b implique ++ a == ++ b » seul
n'offrait pas la garantie multipass [1] 		requiert également « a == b
implique ++ a ! = b » [2]
LWG 3798 C++20 __LegacyForwardIterator requérait
std:: iter_reference_t < It > soit un type référence lvalue 		autorise également les types
référence rvalue
  1. ↑ Dans le scénario où a et b utilisent le même itérateur sous-jacent, l'évaluation de l'expression ++ a == ++ b incrémente effectivement le conteneur sous-jacent deux fois, mais le résultat reste true .
  2. ↑ Formellement, cela implique également ++ b ! = a .

Voir aussi

(C++20)
spécifie qu'un input_iterator est un itérateur avant, prenant en charge la comparaison d'égalité et le multi-passage
(concept)
Bibliothèque d'itérateurs fournit des définitions pour les itérateurs, les traits d'itérateurs, les adaptateurs et les fonctions utilitaires