C++ benannte Anforderungen: LegacyRandomAccessIterator

 

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 LegacyRandomAccessIterator ist ein LegacyBidirectionalIterator, der in konstanter Zeit auf jedes Element zeigen kann.

Wenn ein LegacyRandomAccessIterator it aus einem Container stammt, dann ist it's value_type dasselbe wie das des Containers, sodass Dereferenzierung (*it) den value_type des Containers erhält.

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

Anforderungen

Der Typ It erfüllt LegacyRandomAccessIterator, wenn

• Der Typ It erfüllt LegacyBidirectionalIterator

Und, gegeben

• value_type, der Typ, auf den std::iterator_traits<It>::value_type verweist
• difference_type, der Typ, auf den std::iterator_traits<It>::difference_type verweist
• reference, der Typ, auf den std::iterator_traits<It>::reference verweist
• 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 angegebenen Effekte haben

Ausdruck	Rückgabetyp	Operationale 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 (d.h. die Implementierung darf die in der operativen Semantik gezeigte while-Schleife nicht tatsächlich 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 im Bereich der darstellbaren Werte von difference_type liegen.
i - n	It	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 gleich wie bei b - a Strikte totale Ordnungsrelation !(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 auch LessThanComparable implementiert.

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

Konzept Für die Definition von std::iterator_traits wird das folgende exposition-only-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 exposition-only Konzept __LegacyBidirectionalIterator in LegacyBidirectionalIterator beschrieben ist.

(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 299 (N3066)	C++98	der Rückgabetyp von a[n] war erforderlich konvertierbar zu const value_type& zu sein	der Rückgabetyp ist erforderlich zu reference konvertierbar zu sein
LWG 448	C++98	der Rückgabetyp von a[n] war erforderlich zu value_type konvertierbar zu sein	der Rückgabetyp ist erforderlich zu const value_type& konvertierbar zu sein
LWG 1079	C++98	b - a wurde definiert unter Verwendung von a < b, führte zu zirkulärer Definition	entfernt a < b aus der Definition
LWG 2114 (P2167R3)	C++98	Konvertierbarkeit in bool war zu schwach, um die Erwartungen der Implementierungen widerzuspiegeln	Anforderungen verstärkt

Siehe auch

random_access_iterator (C++20)	spezifiziert, dass ein bidirectional_iterator ein Zufallszugriff-Iterator ist, der die Vorwärtsbewegung in konstanter Zeit und Indizierung unterstützt (Konzept)
Iterator-Bibliothek	stellt Definitionen für Iteratoren, Iterator-Traits, Adaptoren und Hilfsfunktionen bereit