Namespaces
Variants

    std::ranges::views::reverse, std::ranges::reverse_view

    Von de.cppreference.net
     
    C++
     
    Ranges-Bibliothek
    Bereichsadapter
     
    Definiert in Header <ranges> 
    template< ranges::view V >
    requires ranges::bidirectional_range<V>
class reverse_view
    : public ranges::view_interface<reverse_view<V>>
    		(1) (seit C++20) 
    namespace views {
    inline constexpr /* unspecified */ reverse = /* unspecified */;
}
    		(2) (seit C++20)
    Aufrufsignatur
    		 
    template< ranges::viewable_range R >
    requires /* see below */
constexpr ranges::view auto reverse( R&& r );
    		(seit C++20)
    1) Ein Bereichsadapter, der einen View des zugrundeliegenden view in umgekehrter Reihenfolge darstellt.
    2) RangeAdaptorObject. Der Ausdruck views::reverse(e) ist ausdrucksäquivalent zu einem der folgenden Ausdrücke, außer dass e nur einmal ausgewertet wird:
    • e.base(), wenn der Typ von e eine (möglicherweise cv-qualifizierte) Spezialisierung von reverse_view ist;
    • andernfalls, wenn der Typ von e (möglicherweise cv-qualifiziert) ranges::subrange<std::reverse_iterator<I>, std::reverse_iterator<I>, K> für einen Iteratortyp I und einen Wert K vom Typ ranges::subrange_kind ist:
    • ranges::subrange<I, I, K>(e.end().base(), e.begin().base(), e.size()), wenn K ranges::subrange_kind::sized ist;
    • andernfalls ranges::subrange<I, I, K>(e.end().base(), e.begin().base());
    • andernfalls ranges::reverse_view{e}.
    Mit anderen Worten, views::reverse entpackt nach Möglichkeit umgekehrte Views.

    Ein reverse_view modelliert immer bidirectional_range und common_range, und es modelliert borrowed_range, sized_range oder random_access_range, wenn der zugrundeliegende View-Typ V das entsprechende Konzept modelliert.

    Datenmitglieder

    Member Beschreibung
    V base_ (private) die zugrundeliegende View
    ( exposition-only member object* )
    non-propagating-cache < ranges:: iterator_t < V >> cached_end_ (private)
    (nur vorhanden, wenn V nicht common_range erfüllt)     		ein Objekt, das das Ergebnis von Aufrufen an begin() zwischenspeichert
    ( exposition-only member object* )

    Memberfunktionen

    		Konstruiert eine reverse_view
    (Öffentliche Elementfunktion)
    		Gibt die zugrundeliegende Ansicht V zurück
    (Öffentliche Elementfunktion)
    		Gibt den Beginn-Iterator der reverse_view zurück
    (Öffentliche Elementfunktion)
    		Gibt den Ende-Iterator der reverse_view zurück
    (Öffentliche Elementfunktion)
    		Gibt die Größe der Ansicht zurück, falls sie begrenzt ist
    (Öffentliche Elementfunktion)
    (C++26)
    		Gibt die ungefähre Größe des zugrundeliegenden approximately_sized_range zurück
    (Öffentliche Elementfunktion)
    Geerbt von ranges::view_interface
    		gibt zurück, ob die abgeleitete Ansicht leer ist, nur verfügbar, wenn sie sized_range oder forward_range
    erfüllt (öffentliche Elementfunktion von std::ranges::view_interface<D>)
    (C++23)
    		 gibt einen konstanten Iterator zum Anfang des Bereichs zurück
    (öffentliche Elementfunktion von std::ranges::view_interface<D>)
    (C++23)
    		 gibt einen Sentinel für den konstanten Iterator des Bereichs zurück
    (öffentliche Elementfunktion von std::ranges::view_interface<D>)
    		gibt zurück, ob die abgeleitete Ansicht nicht leer ist, nur verfügbar, wenn ranges::empty darauf anwendbar ist
    (öffentliche Elementfunktion von std::ranges::view_interface<D>)
    		gibt das erste Element in der abgeleiteten Ansicht zurück, verfügbar, wenn sie forward_range
    erfüllt (öffentliche Elementfunktion von std::ranges::view_interface<D>)
    		gibt das letzte Element in der abgeleiteten Ansicht zurück, nur verfügbar, wenn sie bidirectional_range und common_range
    erfüllt (öffentliche Elementfunktion von std::ranges::view_interface<D>)
    		gibt das nte Element in der abgeleiteten Ansicht zurück, nur verfügbar, wenn sie random_access_range
    erfüllt (öffentliche Elementfunktion von std::ranges::view_interface<D>)

    std::ranges::reverse_view:: reverse_view

    reverse_view ( ) requires std:: default_initializable < V > = default ;
    		(1) (seit C++20)
    constexpr reverse_view ( V r ) ;
    		(2) (seit C++20)
    1) Wertinitialisiert base_  über seinen Standard-Memberinitialisierer ( = V ( ) ).
    2) Initialisiert base_  mit std :: move ( r ) .

    Parameter

    r - umzukehrender Bereich

    std::ranges::reverse_view:: base

    constexpr V base ( ) const & requires std:: copy_constructible < V > ;
    		(1) (seit C++20)
    constexpr V base ( ) && ;
    		(2) (seit C++20)

    Gibt die zugrundeliegende Ansicht zurück.

    1) Kopierkonstruiert das Ergebnis aus der zugrundeliegenden Ansicht. Entspricht return base_  ; .
    2) Verschiebt das Ergebnis aus der zugrundeliegenden Ansicht. Entspricht return std :: move ( base_  ) ; .

    std::ranges::reverse_view:: begin

    constexpr std:: reverse_iterator < ranges:: iterator_t < V >> begin ( ) ;
    		(1) (seit C++20)
    (2) (seit C++20)
    constexpr auto begin ( ) const requires ranges:: common_range < const V > ;
    		(3) (seit C++20)
    1) Gibt std:: make_reverse_iterator ( ranges:: next ( ranges:: begin ( base_  ) ,
    ranges:: end ( base_  ) ) )     zurück.
    Um die vom range -Konzept geforderte amortisierte konstante Zeitkomplexität bereitzustellen, speichert diese Funktion das Ergebnis im Cache-Objekt für nachfolgende Aufrufe.
    2,3) Entspricht return std:: make_reverse_iterator ( ranges:: end ( base_  ) ) ; .

    std::ranges::reverse_view:: end

    (1) (seit C++20)
    constexpr auto end ( ) const requires ranges:: common_range < const V > ;
    		(2) (seit C++20)

    Entspricht return std:: make_reverse_iterator ( ranges:: begin ( base_  ) ) ; .

    std::ranges::reverse_view:: size

    constexpr auto size ( ) requires ranges:: sized_range < V > ;
    		(1) (seit C++20)
    constexpr auto size ( ) const requires ranges:: sized_range < const V > ;
    		(2) (seit C++20)

    Gibt die Größe der View zurück, falls die View begrenzt ist. Entspricht return ranges:: size ( base_  ) ; .

    std::ranges::as_rvalue_view:: reserve_hint

    constexpr auto reserve_hint ( )
    requires ranges :: approximately_sized_range < V > ;
    		(1) (seit C++26)
    constexpr auto reserve_hint ( ) const
    requires ranges :: approximately_sized_range < const V > ;
    		(2) (seit C++26)

    Gibt ranges :: reserve_hint ( base_  ) zurück.

    Deduktionsanleitungen

    template < class R >
    reverse_view ( R && ) - > reverse_view < views:: all_t < R >> ;
    		(seit C++20)

    Hilfsvorlagen

    template < class T >

    constexpr bool enable_borrowed_range < std :: ranges :: reverse_view < T >> =

    ranges:: enable_borrowed_range < T > ;
    		(seit C++20)

    Diese Spezialisierung von std::ranges::enable_borrowed_range bewirkt, dass reverse_view borrowed_range erfüllt, wenn die zugrunde liegende Ansicht diese Bedingung erfüllt.

    Hinweise

    Feature-Test Makro Wert Std Funktion
    __cpp_lib_ranges_reserve_hint 202502L (C++26) ranges::approximately_sized_range und reserve_hint

    Beispiel

    Diesen Code ausführen 
    #include <iostream>
#include <ranges>
int main()
{
    static constexpr auto il = {3, 1, 4, 1, 5, 9};
    std::ranges::reverse_view rv{il};
    for (int i : rv)
        std::cout << i << ' ';
    std::cout << '\n';
    for (int i : il | std::views::reverse)
        std::cout << i << ' ';
    std::cout << '\n';
    // operator[] is inherited from std::view_interface
    for (auto i{0U}; i != rv.size(); ++i)
        std::cout << rv[i] << ' ';
    std::cout << '\n';
}

    Ausgabe: 

    9 5 1 4 1 3
9 5 1 4 1 3
9 5 1 4 1 3

    Fehlerberichte

    Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

    DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
    LWG 3494 C++20 reverse_view war nie ein borrowed_range es ist ein borrowed_range wenn seine zugrunde liegende Ansicht es ist

    Siehe auch

    		Iterator-Adapter für die Traversierung in umgekehrter Reihenfolge
    (Klassen-Template)
    (C++20)
    		kehrt die Reihenfolge der Elemente in einem Bereich um
    (Algorithmus-Funktionsobjekt)
    (C++20)
    		erstellt eine Kopie eines Bereichs, die umgekehrt ist
    (Algorithmus-Funktionsobjekt)