Namespaces
Variants

C++ named requirements: LegacyInputIterator

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

Un LegacyInputIterator est un LegacyIterator qui peut lire l'élément pointé. LegacyInputIterator ne garantit sa validité que pour les algorithmes à parcours unique : une fois qu'un LegacyInputIterator i a été incrémenté, toutes les copies de sa valeur précédente peuvent être invalidées.

Table des matières

Exigences

Type Définition
X Un type d'itérateur d'entrée
T Le type de valeur de X (c'est-à-dire std:: iterator_traits < X > :: value_type )
R std:: iterator_traits < X > :: reference
Valeur Définition
i , j Valeurs de type X ou const X
r Une valeur de type X&
Autre Définition
m Un identifiant qui peut désigner un membre de données ou une fonction membre


X satisfait LegacyInputIterator si toutes les conditions suivantes sont satisfaites :

Expression Type Sémantique
i ! = j
un type satisfaisant BooleanTestable (jusqu'en C++20)
un type modélisant boolean-testable (depuis C++20)
Précondition i et j sont dans le domaine de == .
Effet Équivalent à ! ( i == j ) .
* i R , convertible en T Précondition i est déréférençable .
Effet
  • L'expression ( void ) * i, * i est équivalente à * i .
  • Si i et j sont dans le domaine de == , et i == j , alors * i est équivalent à * j .
i - > m Précondition i est déréférençable.
Effet Équivalent à ( * i ) . m .
++ r X& Précondition r est déréférençable.
Postcondition
  • r est déréférençable ou r est après-la-fin.
  • Toute copie de la valeur précédente de r n'est plus requise d'être déréférençable ou d'être dans le domaine de == .
( void ) r ++ Effet Équivalent à ( void ) ++ r .
* r ++ convertible en T Effet Équivalent à T x = * r ; ++ r ; return x ; .

Domaine d'égalité

Le terme le domaine de == est utilisé dans le sens mathématique ordinaire pour désigner l'ensemble des valeurs qui peuvent être comparées en utilisant == . Cet ensemble peut changer au fil du temps.

Chaque algorithme impose des exigences supplémentaires sur le domaine d'égalité pour les valeurs d'itérateur qu'il utilise. Ces exigences peuvent être déduites des utilisations que l'algorithme fait de == et ! = .

Notes

Pour un itérateur d'entrée X qui n'est pas un LegacyForwardIterator , std:: iterator_traits < X > :: reference n'a pas besoin d'être un type référence : le déréférencement d'un itérateur d'entrée peut retourner un objet proxy ou std:: iterator_traits < X > :: value_type lui-même par valeur (comme dans le cas de std::istreambuf_iterator ).

Concept

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

template < class I >

concept __LegacyInputIterator =
__LegacyIterator < I > && std:: equality_comparable < I > && requires ( I i )
{
typename std:: incrementable_traits < I > :: difference_type ;
typename std:: indirectly_readable_traits < I > :: value_type ;
typename std:: common_reference_t < std:: iter_reference_t < I > && ,
typename std:: indirectly_readable_traits < I > :: value_type & > ;
* i ++ ;
typename std:: common_reference_t < decltype ( * i ++ ) && ,
typename std:: indirectly_readable_traits < I > :: value_type & > ;
requires std:: signed_integral < typename std:: incrementable_traits < I > :: difference_type > ;

} ;

où le concept à titre d'exposition uniquement __LegacyIterator est décrit dans LegacyIterator .

(depuis 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 Applicable à Comportement publié Comportement corrigé
LWG 98 C++98 le type de retour de * i ++ devait être T il peut être n'importe quel type convertible en T
LWG 2114
( P2167R3 ) 		C++98 la convertibilité en bool était trop faible pour
refléter les attentes des implémentations 		exigences renforcées

Voir aussi

(C++20)
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)
Bibliothèque d'itérateurs fournit des définitions pour les itérateurs, les traits d'itérateurs, les adaptateurs et les fonctions utilitaires