Namespaces
Variants

C++ named requirements: LegacyRandomAccessIterator

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

Ein LegacyRandomAccessIterator ist ein LegacyBidirectionalIterator der in konstanter Zeit auf jedes Element bewegt werden kann.

Wenn ein LegacyRandomAccessIterator it von einem Container stammt, dann ist it 's value_type identisch mit dem des Containers, daher ergibt die Dereferenzierung ( * it ) den value_type des Containers.

Ein Zeiger auf ein Element eines Arrays erfüllt alle Anforderungen eines LegacyRandomAccessIterator .

Inhaltsverzeichnis

Anforderungen

Der Typ It erfüllt die Anforderungen von LegacyRandomAccessIterator wenn

Und, gegeben

  • value_type , der Typ bezeichnet durch std:: iterator_traits < It > :: value_type
  • difference_type , der Typ bezeichnet durch std:: iterator_traits < It > :: difference_type
  • reference , der Typ bezeichnet durch std:: iterator_traits < It > :: reference
  • i , a , b , Objekte vom Typ It oder const It
  • r , ein Lvalue vom Typ It
  • n , eine Ganzzahl vom Typ difference_type

Die folgenden Ausdrücke müssen gültig sein und ihre spezifizierten Effekte haben:

**Übersetzungsdetails:** - "meets" → "erfüllt" (fachlich korrekte Übersetzung für Requirements) - "models" → "modelliert" (fachlich korrekte Übersetzung für Concepts) - "until C++20" → "bis C++20" - "since C++20" → "seit C++20" - C++-Code (`a >= b`, `!(a < b)`) und Fachbegriffe (`BooleanTestable`, `boolean-testable`) wurden nicht übersetzt - HTML-Tags und Attribute bleiben unverändert
Ausdruck Rückgabetyp Operative Semantik Anmerkungen
r + = n It& difference_type m = n ;

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

  • n kann sowohl positiv als auch negativ sein
  • Die Komplexität ist konstant (das heißt, die Implementierung kann die in der operationalen Semantik gezeigte while-Schleife tatsächlich nicht ausführen)
a + n

n + a

It It temp = a ;

return temp + = n ;

  • n kann sowohl positiv als auch negativ sein
  • a + n == n + a
r - = n It& return r + = - n ; Der absolute Wert von n muss innerhalb des Bereichs der darstellbaren Werte von difference_type liegen.
i - n Es It temp = i ;
return temp - = n ;
b - a difference_type return n ;
(siehe Vorbedingung)

Vorbedingung:

  • Es existiert ein Wert n vom Typ difference_type , sodass a + n == b

Nachbedingung:

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

erfüllt BooleanTestable

(bis C++20)

modelliert boolean-testable

(seit C++20)
Äquivalent zu return b - a > 0 ; Vorbedingung:
  • identisch mit b - a

Strenge Totalordnung:

  • ! ( a < a )
  • wenn a < b dann ! ( b < a )
  • wenn a < b und b < c dann a < c
  • a < b oder b < a oder a == b
    (genau einer der Ausdrücke ist wahr)
a > b

erfüllt BooleanTestable

(bis C++20)

modelliert boolean-testable

(seit C++20)
b < a Totale Ordnungsrelation entgegengesetzt zu a < b
a >= b

erfüllt BooleanTestable

(bis C++20)

modelliert boolean-testable

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

erfüllt BooleanTestable

(bis C++20)

modelliert boolean-testable

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

Die obigen Regeln implizieren, dass LegacyRandomAccessIterator ebenfalls LessThanComparable implementiert.

Ein mutable LegacyRandomAccessIterator ist ein LegacyRandomAccessIterator , der zusätzlich die Anforderungen eines LegacyOutputIterator erfüllt.

Konzept

Für die Definition von std::iterator_traits wird das folgende, nur zur Darstellung dienende Konzept definiert.

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 >> ;

} ;

wobei das nur zur Darstellung dienende Konzept __LegacyBidirectionalIterator in LegacyBidirectionalIterator beschrieben wird.

(seit C++20)

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
LWG 299
( N3066 ) 		C++98 Der Rückgabetyp von a [ n ] musste
konvertierbar zu const value_type & sein 		Der Rückgabetyp muss
konvertierbar zu reference sein
LWG 448 C++98 Der Rückgabetyp von a [ n ] musste
konvertierbar zu value_type sein 		Der Rückgabetyp muss
konvertierbar zu const value_type & [1] sein
LWG 1079 C++98 b - a wurde unter Verwendung von a < b definiert,
führte zu zirkulärer Definition 		Entfernte a < b aus der Definition
LWG 2114
( P2167R3 ) 		C++98 Konvertierbarkeit zu bool war zu schwach, um die Erwartungen der Implementierungen widerzuspiegeln Anforderungen verstärkt
  1. ↑ LWG issue 299 wurde nach dieser Entscheidung wiedereröffnet.

Siehe auch

(C++20)
spezifiziert, dass ein bidirectional_iterator ein Random-Access-Iterator ist, der Vorwärts- und Rückwärtsbewegung in konstanter Zeit und Indizierung unterstützt
(Konzept)
Iterator-Bibliothek stellt Definitionen für Iteratoren, Iterator-Traits, Adapter und Hilfsfunktionen bereit