Namespaces
Variants

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

From cppreference.net
C++
Ranges library
Range adaptors
Definiert im 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 /* nicht spezifiziert */ as_rvalue = /* nicht spezifiziert */ ;

}
(2) (seit C++23)
Aufrufsignatur
template < ranges:: viewable_range R >

requires /* siehe unten */

constexpr ranges:: view auto as_rvalue ( R && r ) ;
(seit C++23)
1) Ein Bereichsadapter, der eine Sicht auf die zugrundeliegende view darstellt, deren Elemente R-Werte sind.
2) RangeAdaptorObject . Sei e ein Subausdruck und sei T gleich decltype ( ( e ) ) . Dann ist der Ausdruck views :: as_rvalue ( e ) ausdrucksäquivalent zu:

Inhaltsverzeichnis

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 std::ranges::view_interface
gibt zurück, ob die abgeleitete Ansicht leer ist, bereitgestellt nur wenn sie sized_range oder forward_range erfüllt
(ö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, bereitgestellt nur wenn ranges::empty darauf anwendbar ist
(öffentliche Elementfunktion von std::ranges::view_interface<D> )
gibt das erste Element in der abgeleiteten Ansicht zurück, bereitgestellt wenn sie forward_range erfüllt
(öffentliche Elementfunktion von std::ranges::view_interface<D> )
gibt das letzte Element in der abgeleiteten Ansicht zurück, bereitgestellt nur wenn sie bidirectional_range und common_range erfüllt
(öffentliche Elementfunktion von std::ranges::view_interface<D> )
gibt das n te Element in der abgeleiteten Ansicht zurück, bereitgestellt nur wenn sie random_access_range erfüllt
(ö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)