Namensräume
Varianten
Aktionen

std::experimental::ranges::RandomAccessIterator

Von cppreference.com
< cpp‎ | experimental‎ | ranges
 
 
 
 
Iterator-Bibliothek
Iterator-Konzepte
Indirekte aufrufbare Konzepte
                                                  
                                                  
                                                  
Gemeinsame Algorithmus-Anforderungen
                                                  
Konzept-Dienstprogramme
Iterator-Dienstprogramme und -Operationen
Iterator-Traits
Iterator-Adapter
Stream-Iteratoren
 
Definiert in Header <experimental/ranges/iterator>
template< class I >

concept bool RandomAccessIterator =
    BidirectionalIterator<I> &&
    DerivedFrom<ranges::iterator_category_t<I>, ranges::random_access_iterator_tag> &&
    StrictTotallyOrdered<I> &&
    SizedSentinel<I, I> &&
    requires(I i, const I j, const ranges::difference_type_t<I> n) {
        { i += n } -> Same<I>&;
        { j + n }  -> Same<I>&&;
        { n + j }  -> Same<I>&&;
        { i -= n } -> Same<I>&;
        { j - n }  -> Same<I>&&;
        j[n];
        requires Same<decltype(j[n]), ranges::reference_t<I>>;

    };
(Ranges TS)

Das Konzept RandomAccessIterator<I> verfeinert BidirectionalIterator durch Hinzufügen von Unterstützung für konstante Zeit-Fortschaltung mit den Operatoren +=, +, -= und -, konstante Zeit-Entfernungsmessung mit - und Array-Notation mit Subskriptierung.

Seien a und b gültige Iteratoren vom Typ I, so dass b von a erreichbar ist, und sei n ein Wert vom Typ ranges::difference_type_t<I> gleich b - a. RandomAccessIterator<I> ist nur dann erfüllt, wenn

  • (a += n) gleich b ist.
  • std::addressof(a += n) gleich std::addressof(a) ist.
  • (a + n) ist gleich (a += n).
  • (a + n) ist gleich (n + a).
  • Für zwei beliebige positive ganze Zahlen x und y gilt, wenn a + (x + y) gültig ist, dann ist a + (x + y) gleich (a + x) + y.
  • a + 0 ist gleich a.
  • Wenn (a + (n - 1)) gültig ist, dann ist --b gleich (a + (n - 1)).
  • (b += -n) und (b -= n) sind beide gleich a.
  • std::addressof(b -= n) ist gleich std::addressof(b).
  • (b - n) ist gleich (b -= n).
  • Wenn b dereferenzierbar ist, dann ist a[n] gültig und gleich *b.
  • bool(a <= b) ist true.

[bearbeiten] Gleichheitserhaltung

Ein Ausdruck ist gleichheitserhaltend, wenn er bei gleichen Eingaben gleiche Ausgaben liefert.

  • Die Eingaben für einen Ausdruck bestehen aus seinen Operanden.
  • Die Ausgaben eines Ausdrucks bestehen aus seinem Ergebnis und allen von dem Ausdruck modifizierten Operanden (falls vorhanden).

Jeder Ausdruck, der gleichheitserhaltend sein muss, muss außerdem stabil sein: Zwei Auswertungen eines solchen Ausdrucks mit denselben Eingabeobjekten müssen gleiche Ausgaben liefern, solange keine explizite zwischenzeitliche Modifikation dieser Eingabeobjekte erfolgt.

Sofern nicht anders angegeben, muss jeder in einem requires-expression verwendete Ausdruck gleichheitserhaltend und stabil sein, und die Auswertung des Ausdrucks darf nur seine nicht-konstanten Operanden modifizieren. Operanden, die konstant sind, dürfen nicht modifiziert werden.

[bearbeiten] Implizite Ausdrucksvariationen

Ein requires-expression, der einen Ausdruck verwendet, der für einen konstanten lvalue-Operanden nicht-modifizierend ist, erfordert implizit auch zusätzliche Variationen dieses Ausdrucks, die einen nicht-konstanten lvalue oder (möglicherweise konstanten) rvalue für den gegebenen Operanden akzeptieren, es sei denn, eine solche Ausdrucksvariation ist explizit mit abweichender Semantik erforderlich. Diese impliziten Ausdrucksvariationen müssen die gleichen semantischen Anforderungen des deklarierten Ausdrucks erfüllen. Das Ausmaß, in dem eine Implementierung die Syntax der Variationen validiert, ist nicht spezifiziert.