Namespaces
Variants

C++ named requirements: LegacyInputIterator

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

Ein LegacyInputIterator ist ein LegacyIterator , der vom gezeigten Element lesen kann. LegacyInputIterator s garantieren Gültigkeit nur für Einmal-Durchlauf-Algorithmen: Sobald ein LegacyInputIterator i inkrementiert wurde, können alle Kopien seines vorherigen Wertes ungültig werden.

Inhaltsverzeichnis

Anforderungen

Typ Definition
X Ein Input-Iterator-Typ
T Der value type von X (d.h. std:: iterator_traits < X > :: value_type )
R std:: iterator_traits < X > :: reference
Wert Definition
i , j Werte vom Typ X oder const X
r Ein Wert vom Typ X&
Sonstiges Definition
m Ein Bezeichner, der möglicherweise ein Datenmitglied oder eine Memberfunktion bezeichnet


X erfüllt LegacyInputIterator wenn alle folgenden Bedingungen erfüllt sind:

Ausdruck Typ Semantik
i ! = j
ein Typ, der BooleanTestable erfüllt (bis C++20)
ein Typ, der boolean-testable modelliert (seit C++20)
Vorbedingung i und j befinden sich in der Domäne von == .
Effekt Äquivalent zu ! ( i == j ) .
* i R , konvertierbar zu T Vorbedingung i ist dereferenzierbar .
Effekt
  • Der Ausdruck ( void ) * i, * i ist äquivalent zu * i .
  • Wenn i und j in der Domäne von == liegen und i == j , dann ist * i äquivalent zu * j .
i - > m Vorbedingung i ist dereferenzierbar.
Effekt Äquivalent zu ( * i ) . m .
++ r X& Vorbedingung r ist dereferenzierbar.
Nachbedingung
  • r ist dereferenzierbar oder r ist past-the-end.
  • Kopien des vorherigen Werts von r müssen nicht mehr dereferenzierbar sein oder in der Domäne von == liegen.
( void ) r ++ Effekt Äquivalent zu ( void ) ++ r .
* r ++ konvertierbar zu T Effekt Äquivalent zu T x = * r ; ++ r ; return x ; .

Gleichheitsbereich

Der Begriff der Definitionsbereich von == wird im gewöhnlichen mathematischen Sinne verwendet, um die Menge der Werte zu bezeichnen, die mit == verglichen werden können. Diese Menge kann sich im Laufe der Zeit ändern.

Jeder Algorithmus stellt zusätzliche Anforderungen an den Gleichheitsbereich für die Iteratorwerte, die er verwendet. Diese Anforderungen können aus den Verwendungen abgeleitet werden, die der Algorithmus von == und ! = macht.

Hinweise

Für einen Eingabeiterator X , der kein LegacyForwardIterator ist, std:: iterator_traits < X > :: reference muss kein Referenztyp sein: Das Dereferenzieren eines Eingabeiterators kann ein Proxy-Objekt oder std:: iterator_traits < X > :: value_type selbst als Wert zurückgeben (wie im Fall von std::istreambuf_iterator ).

Konzept

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

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

} ;

wobei das nur zur Darstellung dienende Konzept __LegacyIterator in LegacyIterator 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 Korrigiertes Verhalten
LWG 98 C++98 der Rückgabetyp von * i ++ musste T sein es kann jeder zu T konvertierbare Typ sein
LWG 2114
( P2167R3 ) 		C++98 Konvertierbarkeit zu bool war zu schwach, um
die Erwartungen der Implementierungen widerzuspiegeln 		Anforderungen verstärkt

Siehe auch

(C++20)
spezifiziert, dass ein Typ ein Eingabe-Iterator ist, das heißt, seine referenzierten Werte können gelesen werden und er kann sowohl prä- als auch post-inkrementiert werden
(Konzept)
Iterator-Bibliothek stellt Definitionen für Iteratoren, Iterator-Traits, Adapter und Hilfsfunktionen bereit