C++ benannte Anforderungen: LegacyForwardIterator

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

C++ benannte Anforderungen

Basis DefaultConstructible MoveConstructible (C++11) CopyConstructible CopyAssignable MoveAssignable (C++11) Destructible Typeneigenschaften ScalarType PODType TriviallyCopyable (C++11) TrivialType (C++11) StandardLayoutType (C++11)   ImplicitLifetimeType Bibliothekweit BooleanTestable EqualityComparable LessThanComparable Swappable ValueSwappable (C++11) NullablePointer (C++11) Hash (C++11) Allocator FunctionObject Callable Predicate BinaryPredicate Compare

Container Container ReversibleContainer AllocatorAwareContainer SequenceContainer ContiguousContainer (C++17) AssociativeContainer UnorderedAssociativeContainer (C++11)   Container-Element DefaultInsertable (C++11) CopyInsertable (C++11) MoveInsertable (C++11) EmplaceConstructible (C++11) Erasable (C++11) Iterator LegacyIterator LegacyInputIterator LegacyOutputIterator LegacyForwardIterator LegacyBidirectionalIterator LegacyRandomAccessIterator LegacyContiguousIterator (C++17) ConstexprIterator (C++20) Stream-I/O FormattedInputFunction UnformattedInputFunction FormattedOutputFunction UnformattedOutputFunction Formatters BasicFormatter (C++20) Formatter (C++20)

Zufallszahlen SeedSequence (C++11) RandomNumberEngine (C++11) RandomNumberDistribution (C++11) UniformRandomBitGenerator (C++11) RandomNumberEngineAdaptor (C++11) Concurrency BasicLockable (C++11) Lockable (C++11) TimedLockable (C++11) SharedLockable (C++14) SharedTimedLockable (C++14) Mutex (C++11) TimedMutex (C++11) SharedMutex (C++17) SharedTimedMutex (C++14) Bereiche (Ranges) RangeAdaptorObject (C++20) RangeAdaptorClosureObject (C++20) Mehrdimensionale Ansicht LayoutMapping (C++23) LayoutMappingPolicy (C++23) AccessorPolicy (C++23) Sonstiges CharTraits RegexTraits (C++11)   BitmaskType LiteralType (C++11) NumericType UnaryTypeTrait (C++11) BinaryTypeTrait (C++11) TransformationTrait (C++11) Clock (C++11) TrivialClock (C++11)

 

Ein LegacyForwardIterator ist ein LegacyIterator, der Daten aus dem auf das Element verweisenden Element lesen kann.

Im Gegensatz zu LegacyInputIterator und LegacyOutputIterator kann er in Mehrpass-Algorithmen verwendet werden.

Wenn ein LegacyForwardIterator it von einem Container stammt, dann ist der Werttyp von it derselbe wie der des Containers, sodass das Dereferenzieren (*it) den Werttyp des Containers erhält.

Anforderungen

Typ	Definition
X	Ein Forward-Iterator-Typ
T	Der Werttyp 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 vom Typ X bieten eine Mehrpass-Garantie.
• Wenn i und j gleich sind, dann sind entweder i und j beide dereferenzierbar oder keiner von beiden ist dereferenzierbar.
• Wenn i und j beide dereferenzierbar sind, dann ist i == j genau dann, wenn *i und *j an dasselbe Objekt gebunden sind.
• Die folgenden Ausdrücke müssen gültig sein und ihre angegebenen Effekte haben

Ausdruck	Typ	Effekte
r++	konvertierbar zu const X&	Äquivalent zu X x = r; ++r; return x;.
*i++	Ref

Gleichheitsdomäne

Die Domäne von == für Forward-Iteratoren ist die der Iteratoren über dieselbe zugrundeliegende 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 hinter dem Ende derselben leeren Sequenz verweisen würden.

(seit C++14)

Mehrpass-Garantie

Zwei dereferenzierbare Iteratoren a und b vom Typ X bieten die Mehrpass-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 exposition-only-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 exposition-only-Konzept __LegacyInputIterator<T> in LegacyInputIterator beschrieben ist.

(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	geändert zum Typ Ref
LWG 1311 (N3066)	C++98	„a == b impliziert ++a == ++b“ allein bot keine Mehrpass-Garantie	fordert auch „a == b impliziert ++a != b“
LWG 3798	C++20	__LegacyForwardIterator erforderte std::iter_reference_t<It> als lvalue-Referenztyp	erlaubt auch rvalue Referenztypen

Siehe auch

forward_iterator (C++20)	spezifiziert, dass ein input_iterator ein Vorwärtsiterator ist, der Gleichheitsvergleich und Multi-Pass unterstützt (Konzept)
Iterator-Bibliothek	stellt Definitionen für Iteratoren, Iterator-Traits, Adaptoren und Hilfsfunktionen bereit