Namespaces
Variants

    std::ranges::views::as_rvalue, std::ranges::as_rvalue_view

    Von de.cppreference.net
     
    C++
     
    Ranges-Bibliothek
    Range-Adapter
     
    Definiert in Header <ranges> 
    template< ranges::view V >
    requires ranges::input_range<V>
class as_rvalue_view
    : public ranges::view_interface<as_rvalue_view<V>>
    		(1) (seit C++23) 
    namespace views {
    inline constexpr /* unspecified */ as_rvalue = /* unspecified */;
}
    		(2) (seit C++23)
    Aufrufsignatur
    		 
    template< ranges::viewable_range R >
    requires /* see below */
constexpr ranges::view auto as_rvalue( R&& r );
    		(seit C++23)
    1) Ein Range-Adapter, der eine View der zugrundeliegenden view darstellt, deren Elemente Rvalues sind.
    2) RangeAdaptorObject. Sei e ein Unterausdruck und sei T decltype((e)). Dann ist der Ausdruck views::as_rvalue(e) ausdrucksäquivalent zu:
    • views::all(e), wenn es ein wohlgeformter Ausdruck ist, T das Konzept input_range modelliert und std::same_as<ranges::range_rvalue_reference_t<T>, ranges::range_reference_t<T>> true ist;
    • as_rvalue_view{e} andernfalls.

    Datenmitglieder

    Mitglied Beschreibung
    V base_ (privat) die zugrundeliegende Ansicht
    ( Nur-Darstellungs-Mitgliedsobjekt* )

    Memberfunktionen

    		konstruiert eine as_rvalue_view
    (öffentliche Elementfunktion)
    		gibt die zugrunde liegende Ansicht V zurück
    (öffentliche Elementfunktion)
    		gibt den Beginn-Iterator der as_rvalue_view zurück
    (öffentliche Elementfunktion)
    		gibt den Ende-Iterator der as_rvalue_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 der zugrunde liegenden approximately_sized_range zurück
    (öffentliche Elementfunktion)
    Geerbt von ranges::view_interface
    		gibt zurück, ob die abgeleitete Ansicht leer ist, nur bereitgestellt, wenn sie erfüllt: sized_range oder forward_range
    (öffentliche Elementfunktion von std::ranges::view_interface<D>)
    (C++23)
    		 gibt einen konstanten Iterator zum Beginn 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 bereitgestellt, wenn ranges::empty auf sie anwendbar ist
    (öffentliche Elementfunktion von std::ranges::view_interface<D>)
    		gibt das erste Element in der abgeleiteten Ansicht zurück, bereitgestellt, wenn sie erfüllt: forward_range
    (öffentliche Elementfunktion von std::ranges::view_interface<D>)
    		gibt das letzte Element in der abgeleiteten Ansicht zurück, nur bereitgestellt, wenn sie erfüllt: bidirectional_range und common_range
    (öffentliche Elementfunktion von std::ranges::view_interface<D>)
    		gibt das n-te Element in der abgeleiteten Ansicht zurück, nur bereitgestellt, wenn sie erfüllt: random_access_range
    (öffentliche Elementfunktion von std::ranges::view_interface<D>)

    std::ranges::as_rvalue_view:: as_rvalue_view

    as_rvalue_view ( ) requires std:: default_initializable < V > = default ;
    		(1) (since C++23)
    constexpr explicit as_rvalue_view ( V base ) ;
    		(2) (since C++23)
    1) Wertinitialisiert base_ über seinen Standard-Member-Initialisierer ( = V ( ) ).
    2) Initialisiert base_ mit std :: move ( base ) .

    Parameter

    base - eine View

    std::ranges::as_rvalue_view:: base

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

    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::as_rvalue_view:: begin

    constexpr auto begin ( ) requires ( ! /*simple-view*/ < V > ) ;
    		(1) (seit C++23)
    constexpr auto begin ( ) const requires ranges:: range < const V > ;
    		(2) (seit C++23)

    Gibt std:: move_iterator ( ranges:: begin ( base_  ) ) zurück.

    std::ranges::as_rvalue_view:: end

    constexpr auto end ( ) requires ( ! /*simple-view*/ < V > ) ;
    		(1) (seit C++23)
    constexpr auto end ( ) const requires ranges:: range < const V > ;
    		(2) (seit C++23)

    Gibt std:: move_iterator ( ranges:: end ( base_  ) ) zurück, falls (1) V oder (2) const V common_range modelliert.

    Gibt andernfalls std:: move_sentinel ( ranges:: end ( base_  ) ) zurück.

    std::ranges::as_rvalue_view:: size

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

    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 >
    as_rvalue_view ( R && ) - > as_rvalue_view < views:: all_t < R >> ;
    		(seit C++23)

    Hilfsvorlagen

    template < class T >

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

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

    Diese Spezialisierung von ranges::enable_borrowed_range bewirkt, dass as_rvalue_view borrowed_range erfüllt, wenn die zugrundeliegende View diese Bedingung erfüllt.

    Hinweise

    Feature-Test Makro Wert Std Feature
    __cpp_lib_ranges_as_rvalue 202207L (C++23) std::ranges::as_rvalue_view
    __cpp_lib_ranges_reserve_hint 202502L (C++26) ranges::approximately_sized_range und reserve_hint

    Beispiel

    Diesen Code ausführen 
    #include <algorithm>
#include <iostream>
#include <ranges>
#include <string>
#include <vector>
int main()
{
    std::vector<std::string> words =
        {"Quick", "red", "\N{FOX FACE}", "jumped", "over", "a", "pterodactyl"};
    std::vector<std::string> new_words;
    std::ranges::copy(
        words | std::views::as_rvalue,
        std::back_inserter(new_words)); // Zeichenketten von words nach new_words verschieben
    auto quoted = std::views::transform([](auto&& s) { return "“" + s + "”"; });
    std::cout << "Alte Wörter: ";
    for (auto&& word : words | std::views::as_rvalue | quoted)
        std::cout << word << ' ';
    std::cout << "\nNeue Wörter: ";
    for (auto&& word : new_words | std::views::as_rvalue | quoted)
        std::cout << word << ' ';
}

    Mögliche Ausgabe: 

    Alte Wörter: “” “” “” “” “” “” “” 
Neue Wörter: “Quick” “red” “🦊” “jumped” “over” “a” “pterodactyl”

    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 4083 C++23 views::as_rvalue akzeptierte früher keine Input-Ranges wurde abgelehnt

    Siehe auch

    (C++20)
    		wandelt das Ergebnis der Dereferenzierung eines Objekts in seinen zugehörigen Rvalue-Referenztyp um
    (Anpassungspunktobjekt)
    (C++11)
    		Iterator-Adapter, der auf einen Rvalue dereferenziert
    (Klassentemplate)
    (C++20)
    		Sentinel-Adapter für std::move_iterator
    (Klassentemplate)
    (C++23)
    		konvertiert eine view in einen constant_range
    (Klassentemplate) (Range-Adapterobjekt)