std::reverse_iterator

 

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

 

Iterator-Bibliothek

Iterator-Konzepte
indirectly_readable (C++20) indirectly_writable (C++20) weakly_incrementable (C++20) incrementable (C++20) is-integer-like is-signed-integer-like (C++20)(C++20)	sentinel_for (C++20) sized_sentinel_for (C++20) input_iterator (C++20) output_iterator (C++20) input_or_output_iterator (C++20)	forward_iterator (C++20) bidirectional_iterator (C++20) random_access_iterator (C++20) contiguous_iterator (C++20)
Iterator-Primitive
input_iterator_tagoutput_iterator_tagforward_iterator_tagbidirectional_iterator_tagrandom_access_iterator_tagcontiguous_iterator_tag (C++20)	iter_value_titer_difference_titer_reference_titer_const_reference_titer_rvalue_reference_titer_common_reference_t (C++20)(C++20)(C++20)(C++23)(C++20)(C++20)	iterator (veraltet in C++17) iterator_traits incrementable_traits (C++20) indirectly_readable_traits (C++20)
Algorithmus-Konzepte und Hilfsprogramme
Indirekte aufrufbare Konzepte
indirectly_unary_invocableindirectly_regular_unary_invocable (C++20)(C++20)	indirect_unary_predicate (C++20) indirect_binary_predicate (C++20)	indirect_equivalence_relation (C++20) indirect_strict_weak_order (C++20)
Gemeinsame Algorithmus-Anforderungen
indirectly_movable (C++20) indirectly_movable_storable (C++20) indirectly_copyable (C++20)	indirectly_copyable_storable (C++20)   indirectly_swappable (C++20) indirectly_comparable (C++20)	permutable (C++20) mergeable (C++20) sortable (C++20)
Dienstprogramme
indirect_result_t (C++20)	projected (C++20)	projected_value_t (C++26)
Iterator-Adapter
reverse_iterator make_reverse_iterator (C++14) move_iterator (C++11) make_move_iterator (C++11) default_sentinel_tdefault_sentinel (C++20)(C++20) unreachable_sentinel_tunreachable_sentinel (C++20)(C++20)	front_insert_iterator back_insert_iterator inserter insert_iterator front_inserter back_inserter move_sentinel (C++20)	common_iterator (C++20) counted_iterator (C++20) basic_const_iterator (C++23) const_iterator (C++23) const_sentinel (C++23) make_const_iterator (C++23) make_const_sentinel (C++23)
Stream-Iteratoren istream_iterator    ostream_iterator istreambuf_iterator ostreambuf_iterator	Iterator-Anpassungspunkte ranges::iter_move (C++20) ranges::iter_swap (C++20)
Iterator-Operationen advance distance prev (C++11)   next (C++11) ranges::advance (C++20) ranges::distance (C++20) ranges::prev (C++20) ranges::next (C++20)	Bereichszugriff begincbegin (C++11)(C++14) rbegincrbegin (C++14)(C++14)   endcend (C++11)(C++14) rendcrend (C++14)(C++14)   sizessize (C++17)(C++20) empty (C++17) data (C++17)

 

std::reverse_iterator

Memberfunktionen

reverse_iterator::reverse_iterator

reverse_iterator::operator=

reverse_iterator::base

reverse_iterator::operator*reverse_iterator::operator->

reverse_iterator::operator[]

reverse_iterator::operator++reverse_iterator::operator+reverse_iterator::operator+=reverse_iterator::operator--reverse_iterator::operator-reverse_iterator::operator-=

Nicht-Member-Funktionen

operator==operator!=operator<operator<=operator>operator>=operator<=> (C++20)

operator+

operator-

iter_move (C++20)

iter_swap (C++20)

make_reverse_iterator (C++14)

 

Definiert in Header <iterator>
template< class Iter > class reverse_iterator;

std::reverse_iterator ist ein Iterator-Adapter, der die Richtung eines gegebenen Iterators umkehrt, welcher mindestens ein LegacyBidirectionalIterator sein muss oder ein bidirectional_iterator modelliert(seit C++20). Anders ausgedrückt, 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, ist die Beziehung &*r == &*(i - 1) immer true (solange r dereferenzierbar ist); somit dereferenziert ein Reverse-Iterator, der aus einem "One-Past-The-End"-Iterator konstruiert wurde, zum letzten Element einer Sequenz.

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

Verschachtelte Typen

Typ Definition iterator_type Iter iterator_category std::iterator_traits<Iter>::iterator_category value_type std::iterator_traits<Iter>::value_type difference_type std::iterator_traits<Iter>::difference_type Zeiger std::iterator_traits<Iter>::pointer Referenz std::iterator_traits<Iter>::reference

(bis C++20)

Typ Definition iterator_type Iter iterator_concept std::random_access_iterator_tag, falls Iter ein std::random_access_iterator modelliert. std::bidirectional_iterator_tag andernfalls. iterator_category std::random_access_iterator_tag, falls std::iterator_traits<Iter>::iterator_category std::derived_from<std::random_access_iterator_tag> modelliert. std::iterator_traits<Iter>::iterator_category andernfalls. value_type std::iter_value_t<Iter> difference_type std::iter_difference_t<Iter> Zeiger std::iterator_traits<Iter>::pointer Referenz std::iter_reference_t<Iter>

(seit C++20)

Datenmitglieder

Mitglied	Beschreibung
Iter current	der zugrunde liegende Iterator (geschütztes Member-Objekt)

Member-Funktionen

(Konstruktor)	konstruiert einen neuen reverse_iterator (öffentliche Memberfunktion)
operator=	weist einen anderen reverse_iterator zu (öffentliche Memberfunktion)
base	greift auf den zugrundeliegenden Iterator zu (öffentliche Memberfunktion)
operator*operator->	greift auf das dereferenzierte Element zu (öffentliche Memberfunktion)
operator[]	greift per Index auf ein Element zu (öffentliche Memberfunktion)
operator++operator++(int)operator+=operator+operator--operator--(int)operator-=operator-	bewegt den reverse_iterator vorwärts oder rückwärts (öffentliche Memberfunktion)

Nicht-Member-Funktionen

operator==operator!=operator<operator<=operator>operator>=operator<=> (C++20)	vergleicht die zugrundeliegenden Iteratoren (Funktionstemplate)
operator+	bewegt den Iterator vorwärts (Funktionstemplate)
operator-	berechnet die Distanz zwischen zwei Iterator-Adaptoren (Funktionstemplate)
iter_move (C++20)	konvertiert das Ergebnis der Dereferenzierung des angepassten zugrunde liegenden Iterators in seinen zugehörigen rvalue-Referenztyp (Funktion)
iter_swap (C++20)	tauscht die Objekte, auf die von zwei angepassten zugrunde liegenden Iteratoren gezeigt wird (Funktionstemplate)
make_reverse_iterator (C++14)	erstellt einen std::reverse_iterator vom Argument abgeleiteten Typ (Funktionsvorlage)

Hilfsschablonen

template< class Iterator1, class Iterator2 >     requires (!std::sized_sentinel_for<Iterator1, Iterator2>) inline constexpr bool disable_sized_sentinel_for     <std::reverse_iterator<Iterator1>, std::reverse_iterator<Iterator2>> = true;		(seit C++20)

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

Mögliche Implementierung

Nachfolgend finden Sie eine Teilimplementierung, die sich auf die Art und Weise konzentriert, wie der innere Iterator gespeichert wird, 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); // <== returns the content of prev }   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; }   // Other member functions, friend functions, and member typedefs are not shown here. };

Anmerkungen

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

Beispiel

Führen Sie diesen Code aus

#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;
    }
 
    // we wish that looping on Stack would be in LIFO order
    // thus we use std::reverse_iterator as an adaptor to existing iterators
    // (which are in this case the simple pointers: [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';
}

Ausgabe

35 25 15 5

Siehe auch

make_reverse_iterator (C++14)	erstellt einen std::reverse_iterator vom Argument abgeleiteten Typ (Funktionsvorlage)
iterator (veraltet in C++17)	Basisklasse zur Vereinfachung der Definition der erforderlichen Typen für einfache Iteratoren (Klassenschablone)