Namespaces
Variants

C++ named requirements: LegacyForwardIterator

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

Ein LegacyForwardIterator ist ein LegacyIterator , der Daten vom referenzierten Element lesen kann.

Im Gegensatz zu LegacyInputIterator und LegacyOutputIterator kann es in Mehrfachdurchlauf-Algorithmen verwendet werden.

Wenn ein LegacyForwardIterator it von einem Container stammt, dann ist it 's Werttyp derselbe wie der des Containers, daher ergibt die Dereferenzierung ( * it ) den Werttyp des Containers.

Inhaltsverzeichnis

Anforderungen

Typ Definition
X Ein Forward-Iterator-Typ
T Der value type von X (d.h. std:: iterator_traits < X > :: value_type )
Ref std:: iterator_traits < X > :: reference
Wert Definition
i , j Werte vom Typ X oder const X
r Ein Wert vom Typ X&

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

  • X erfüllt LegacyInputIterator .
  • X erfüllt DefaultConstructible .
  • Wenn X ein mutable iterator ist, ist Ref eine Referenz auf T .
  • Wenn X ein konstanter Iterator ist, ist Ref eine Referenz auf const T .
  • Objekte des Typs X bieten multi-pass guarantee .
  • Wenn i und j gleich sind, dann sind entweder i und j beide dereferenceable oder keiner von beiden ist dereferenceable.
  • Wenn i und j beide dereferenceable sind, dann gilt i == j genau dann, wenn * i und * j an dasselbe Objekt gebunden sind.
  • Die folgenden Ausdrücke müssen gültig sein und ihre spezifizierten Effekte haben:
Expression Typ Effekte
r ++ konvertierbar zu const X & Äquivalent zu X x = r ;
++ r ;
return x ; .
* i ++ Ref

Gleichheitsbereich

Der Definitionsbereich von == für Forward-Iteratoren ist der von Iteratoren über derselben zugrundeliegenden Sequenz .

Allerdings können wertinitialisierte Forward-Iteratoren verglichen werden und müssen gleich anderen wertinitialisierten Iteratoren desselben Typs sein.

Mit anderen Worten, wertinitialisierte Forward-Iteratoren verhalten sich so, als ob sie über das Ende derselben leeren Sequenz hinausweisen.

(since C++14)

Multi-Pass-Garantie

Zwei dereferenzierbare Iteratoren a und b vom Typ X bieten die Multi-Pass-Garantie wenn alle folgenden Bedingungen erfüllt sind:

  • a == b impliziert ++ a == ++ b .
  • Eine der folgenden Bedingungen ist erfüllt:
  • X ist ein Zeigertyp.
  • Der Ausdruck ( void ) ++ X ( a ) , * a ist äquivalent zum Ausdruck * a .

Konzept

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

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

} ;

wobei das nur zur Darstellung dienende Konzept __LegacyInputIterator<T> in LegacyInputIterator beschrieben wird.

(seit C++20)

Hinweise

Im Gegensatz zum std::forward_iterator Konzept erfordern die LegacyForwardIterator Anforderungen, dass die Dereferenzierung eine Referenz zurückgibt.

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 1212
( N3066 ) 		C++98 der Typ von * i ++ stimmte nicht mit dem Typ von
* i -- überein, wie von LegacyBidirectionalIterator gefordert 		änderte den
Typ zu Ref
LWG 1311
( N3066 ) 		C++98 „ a == b impliziert ++ a == ++ b “ allein
bot keine Multipass-Garantie [1] 		erfordert auch „ a == b
impliziert ++ a ! = b “ [2]
LWG 3798 C++20 __LegacyForwardIterator forderte
std:: iter_reference_t < It > als Lvalue-Referenztyp 		erlaubt auch Rvalue-
Referenztypen
  1. ↑ In dem Szenario, in dem a und b denselben zugrundeliegenden Iterator verwenden, bewirkt die Auswertung des Ausdrucks ++ a == ++ b tatsächlich eine zweifache Inkrementierung des zugrundeliegenden Containers, aber das Ergebnis ist dennoch true .
  2. ↑ Formal erfordert es auch die Implikation ++ b ! = a .

Siehe auch

(C++20)
spezifiziert, dass ein input_iterator ein Forward-Iterator ist, der Gleichheitsvergleiche und Multi-Pass unterstützt
(Konzept)
Iterator-Bibliothek stellt Definitionen für Iteratoren, Iterator-Traits, Adapter und Hilfsfunktionen bereit