std:: reverse_iterator

std::reverse_iterator ist ein Iterator-Adapter, der die Richtung eines gegebenen Iterators umkehrt, der mindestens ein LegacyBidirectionalIterator oder ein Modell von bidirectional_iterator (seit C++20) sein muss. Mit anderen Worten: Wenn ein bidirektionaler Iterator bereitgestellt wird, erzeugt std::reverse_iterator einen neuen Iterator, der sich vom Ende zum Anfang der durch den zugrunde liegenden bidirektionalen Iterator definierten Sequenz bewegt.

Für einen Reverse-Iterator r , der aus einem Iterator i konstruiert wurde, gilt stets die Beziehung & * r == & * ( i - 1 ) (solange r dereferenzierbar ist); daher dereferenziert ein Reverse-Iterator, der aus einem one-past-the-end-Iterator konstruiert wurde, auf das letzte Element in einer Sequenz.

Dies ist der Iterator, der von den Memberfunktionen rbegin() und rend() der Standardbibliothek-Container zurückgegeben wird.

Verschachtelte Typen

1. ↑ ^{1.0 1.1} Die Definition wird bis C++17 durch die Basis- std::iterator Spezialisierung bereitgestellt.

Datenelemente

Memberfunktionen

Nicht-Member-Funktionen

Hilfsvorlagen

Diese partielle Spezialisierung von std::disable_sized_sentinel_for verhindert, dass Spezialisierungen von reverse_iterator das Konzept sized_sentinel_for erfüllen, wenn ihre zugrunde liegenden Iteratoren das Konzept nicht erfüllen.

Mögliche Implementierung

Unten ist eine Teilimplementierung dargestellt, die sich auf die Art der Speicherung des inneren Iterators konzentriert und std::prev nur dann aufruft, wenn der Inhalt über operator * abgerufen wird.

template<class It>
class reverse_iterator
{
protected:
    It current = It();
public:
    reverse_iterator() = default;
    constexpr explicit reverse_iterator(It itr) : current(itr) {}
    template<class U>
        requires (!std::is_same_v<U, It> && std::convertible_to<const U&, It>)
    constexpr explicit reverse_iterator(const U& other) : current(other.base()) {}
    constexpr decltype(auto) operator*() const
    {
        return *std::prev(current); // <== gibt den Inhalt von prev zurück
    }
    constexpr reverse_iterator& operator++() { --current; return *this; }
    constexpr reverse_iterator operator++(int) { auto tmp = *this; ++(*this); return tmp; }
    constexpr reverse_iterator& operator--() { ++current; return *this; }
    constexpr reverse_iterator operator--(int) { auto tmp = *this; --(*this); return tmp; }
    constexpr It base() const { return current; }
    // Andere Member-Funktionen, Friend-Funktionen und Member-Typdefinitionen sind hier nicht dargestellt.
};

Hinweise

std::reverse_iterator funktioniert nicht mit Iteratoren, deren Dereferenzierung eine Referenz auf ein Mitglied von * this zurückgibt (sogenannte "Stashing-Iteratoren"). Ein Beispiel für einen Stashing-Iterator ist MSVC STL's std::filesystem::path::iterator .

Beispiel

#include <cstddef>
#include <iostream>
#include <iterator>
template<typename T, std::size_t SIZE>
class Stack
{
    T arr[SIZE];
    std::size_t pos = 0;
public:
    T pop()
    {
        return arr[--pos];
    }
    Stack& push(const T& t)
    {
        arr[pos++] = t;
        return *this;
    }
    // wir wünschen, dass das Durchlaufen des Stapels in LIFO-Reihenfolge erfolgt
    // daher verwenden wir std::reverse_iterator als Adapter für bestehende Iteratoren
    // (in diesem Fall die einfachen Zeiger: [arr, arr + pos)
    auto begin() { return std::reverse_iterator(arr + pos); }
    auto end() { return std::reverse_iterator(arr); }
};
int main()
{
    Stack<int, 8> s;
    s.push(5).push(15).push(25).push(35);
    for (int val : s)
        std::cout << val << ' ';
    std::cout << '\n';
}

35 25 15 5

Siehe auch