Namespaces
Variants

C++ named requirements: LegacyRandomAccessIterator

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

Un LegacyRandomAccessIterator est un LegacyBidirectionalIterator qui peut être déplacé pour pointer vers n'importe quel élément en temps constant.

Si un LegacyRandomAccessIterator it provient d'un Container , alors le value_type de it est identique à celui du conteneur, donc le déréférencement ( * it ) permet d'obtenir le value_type du conteneur.

Un pointeur vers un élément d'un tableau satisfait toutes les exigences de LegacyRandomAccessIterator .

Table des matières

Exigences

Le type It satisfait LegacyRandomAccessIterator si

Et, étant donné

  • value_type , le type désigné par std:: iterator_traits < It > :: value_type
  • difference_type , le type désigné par std:: iterator_traits < It > :: difference_type
  • reference , le type désigné par std:: iterator_traits < It > :: reference
  • i , a , b , objets de type It ou const It
  • r , une lvalue de type It
  • n , un entier de type difference_type

Les expressions suivantes doivent être valides et avoir leurs effets spécifiés :

Expression Type de retour Sémantique opérationnelle Notes
r + = n It& difference_type m = n ;

if ( m >= 0 ) while ( m -- ) ++ r ;
else while ( m ++ ) -- r ;
return r ;

  • n peut être positif ou négatif
  • La complexité est constante (c'est-à-dire que l'implémentation ne peut pas réellement exécuter la boucle while montrée dans la sémantique opérationnelle)
a + n

n + a

It It temp = a ;

return temp + = n ;

  • n peut être positif ou négatif
  • a + n == n + a
r - = n It& return r + = - n ; La valeur absolue de n doit être dans la plage des valeurs représentables de difference_type .
i - n It It temp = i ;
return temp - = n ;
b - a difference_type return n ;
(voir la précondition)

Précondition :

  • il existe une valeur n de type difference_type telle que a + n == b

Postcondition :

  • b == a + ( b - a ) .
i [ n ] convertible en reference * ( i + n )
a < b

satisfait BooleanTestable

(jusqu'en C++20)

modélise boolean-testable

(depuis C++20)
Équivalent à return b - a > 0 ; Précondition :
  • identique à celle de b - a

Relation d'ordre total strict :

  • ! ( a < a )
  • si a < b alors ! ( b < a )
  • si a < b et b < c alors a < c
  • a < b ou b < a ou a == b
    (exactement une des expressions est vraie)
a > b

satisfait BooleanTestable

(jusqu'en C++20)

modélise boolean-testable

(depuis C++20)
b < a Relation d'ordre total opposée à a < b
a >= b

satisfait BooleanTestable

(jusqu'en C++20)

modélise boolean-testable

(depuis C++20)
! ( a < b )
a <= b

satisfait BooleanTestable

(jusqu'en C++20)

modélise boolean-testable

(depuis C++20)
! ( a > b )

Les règles ci-dessus impliquent que LegacyRandomAccessIterator implémente également LessThanComparable .

Un mutable LegacyRandomAccessIterator est un LegacyRandomAccessIterator qui satisfait également aux exigences du LegacyOutputIterator .

Concept

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

template < class I >

concept __LegacyRandomAccessIterator =
__LegacyBidirectionalIterator < I > && std:: totally_ordered < I > &&
requires ( I i, typename std:: incrementable_traits < I > :: difference_type n )
{
{ i + = n } - > std:: same_as < I & > ;
{ i - = n } - > std:: same_as < I & > ;
{ i + n } - > std:: same_as < I > ;
{ n + i } - > std:: same_as < I > ;
{ i - n } - > std:: same_as < I > ;
{ i - i } - > std:: same_as < decltype ( n ) > ;
{ i [ n ] } - > std:: convertible_to < std:: iter_reference_t < I >> ;

} ;

où le concept uniquement à titre d'exposition __LegacyBidirectionalIterator est décrit dans LegacyBidirectionalIterator .

(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 Appliqué à Comportement publié Comportement corrigé
LWG 299
( N3066 ) 		C++98 le type de retour de a [ n ] était requis
d'être convertible en const value_type & 		le type de retour est requis
d'être convertible en reference
LWG 448 C++98 le type de retour de a [ n ] était requis
d'être convertible en value_type 		le type de retour est requis d'être
convertible en const value_type & [1]
LWG 1079 C++98 b - a était défini en utilisant a < b ,
résultant en une définition circulaire 		supprimé a < b de la définition
LWG 2114
( P2167R3 ) 		C++98 la convertibilité en bool était trop faible pour refléter les attentes des implémentations exigences renforcées
  1. ↑ LWG issue 299 a été rouvert après cette résolution.

Voir aussi

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