Namespaces
Variants

std::ranges:: owning_view

From cppreference.net
C++
Ranges library
Range adaptors
Definiert im Header <ranges>
template < ranges:: range R >

requires std:: movable < R > && ( ! /*is-initializer-list*/ < R > )
class owning_view

: public ranges:: view_interface < owning_view < R >>
(seit C++20)

owning_view ist eine view , die ein alleiniges Eigentum an einem range besitzt. Sie ist nur verschiebbar und speichert diesen range in sich.

Die Konstante /*is-initializer-list*/ < R > in der requires -Klausel ist true genau dann, wenn std:: remove_cvref_t < R > eine Spezialisierung von std::initializer_list ist.

Inhaltsverzeichnis

Datenmitglieder

Member Beschreibung
R r_ der zugrundeliegende Bereich
( Nur zur Veranschaulichung (exposition-only member object*) )

Memberfunktionen

Konstruiert einen owning_view durch Wertinitialisierung oder Move-Konstruktion des gespeicherten Bereichs
(öffentliche Elementfunktion)
Move-Zuweisung des gespeicherten Bereichs
(öffentliche Elementfunktion)
gibt eine Referenz auf den gespeicherten Bereich zurück
(öffentliche Elementfunktion)
gibt den Startiterator des gespeicherten Bereichs zurück
(öffentliche Elementfunktion)
gibt den Sentinel des gespeicherten Bereichs zurück
(öffentliche Elementfunktion)
prüft, ob der gespeicherte Bereich leer ist
(öffentliche Elementfunktion)
gibt die Größe des gespeicherten sized_range zurück
(öffentliche Elementfunktion)
(C++26)
gibt die ungefähre Größe des gespeicherten approximately_sized_range zurück
(öffentliche Elementfunktion)
gibt den Zeiger auf den Anfang des gespeicherten contiguous_range zurück
(öffentliche Elementfunktion)
Geerbt von std::ranges::view_interface
(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, 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::owning_view:: owning_view

owning_view ( ) requires std:: default_initializable < R > = default ;
(1) (seit C++20)
owning_view ( owning_view && other ) = default ;
(2) (seit C++20)
constexpr owning_view ( R && t ) ;
(3) (seit C++20)
1) Standardkonstruktor. Wertinitialisiert r_ durch seinen Standard-Member-Initialisierer ( = R ( ) ).
2) Move-Konstruktor. Move-konstruiert r_ aus dem von other .
3) Move-konstruiert r_ aus t .

Parameter

other - ein weiteres owning_view zum Verschieben
t - Bereich zum Verschieben

Anmerkungen

owning_view definiert keinen expliziten Kopierkonstruktor. owning_view ist nur verschiebbar.

std::ranges::owning_view:: operator=

owning_view & operator = ( owning_view && other ) = default ;
(seit C++20)

Move-Zuweisungsoperator. Weist r_ von other per Move zu.

Parameter

other - ein weiteres owning_view , von dem verschoben wird

Rückgabewert

* this

Anmerkungen

owning_view definiert keinen expliziten Kopierzuweisungsoperator. owning_view ist nur verschiebbar (move-only).

std::ranges::owning_view:: base

constexpr R & base ( ) & noexcept ;
(1) (seit C++20)
constexpr const R & base ( ) const & noexcept ;
(2) (seit C++20)
constexpr R && base ( ) && noexcept ;
(3) (seit C++20)
constexpr const R && base ( ) const && noexcept ;
(4) (seit C++20)

Gibt eine Referenz auf den gespeicherten Bereich zurück und behält dabei Wertkategorie und Const-Qualifizierung bei.

Rückgabewert

1,2) r_
3,4) std :: move ( r_  )

std::ranges::owning_view:: begin

constexpr ranges:: iterator_t < R > begin ( ) ;
(1) (seit C++20)
constexpr auto begin ( ) const requires ranges:: range < const R > ;
(2) (seit C++20)

Gibt ranges:: begin ( r_  ) zurück.

std::ranges::owning_view:: end

constexpr ranges:: sentinel_t < R > end ( ) ;
(1) (seit C++20)
constexpr auto end ( ) const requires ranges:: range < const R > ;
(2) (seit C++20)

Gibt ranges:: end ( r_  ) zurück.

std::ranges::owning_view:: empty

constexpr bool empty ( ) requires requires { ranges:: empty ( r_ ) ; } ;
(1) (seit C++20)
constexpr bool empty ( ) const requires requires { ranges:: empty ( r_ ) ; } ;
(2) (seit C++20)

Gibt ranges:: empty ( r_  ) zurück.

std::ranges::owning_view:: size

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

Gibt ranges:: size ( r_  ) zurück.

std::ranges::owning_view:: reserve_hint

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

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

std::ranges::owning_view:: data

constexpr auto data ( ) requires ranges:: contiguous_range < R > ;
(1) (since C++20)
constexpr auto data ( ) const requires ranges:: contiguous_range < const R > ;
(2) (since C++20)

Gibt ranges:: data ( r_  ) zurück.

**Übersetzungserläuterungen:** - HTML-Tags, Attribute und Code-Blöcke wurden unverändert gelassen - C++-spezifische Begriffe wie `constexpr`, `auto`, `requires`, `ranges::contiguous_range` wurden nicht übersetzt - Nur der beschreibende Text "Returns" wurde präzise als "Gibt" übersetzt - Die Formatierung und Struktur der Webseite wurde vollständig beibehalten - Professionelle, technische Übersetzung für C++-Dokumentation

Hilfsvorlagen

template < class T >

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

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

Diese Spezialisierung von ranges:: enable_borrowed_range bewirkt, dass owning_view borrowed_range erfüllt, wenn der zugrundeliegende Range diese Bedingung erfüllt.

Hinweise

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

Beispiel

Diesen Code ausführen 
#include <cassert>
#include <iostream>
#include <ranges>
#include <string>
int main()
{
    using namespace std::literals;
    std::ranges::owning_view ov{"cosmos"s}; // der abgeleitete Typ von R ist std::string;
                                            // "ov" ist der einzige Besitzer dieses Strings
    assert(
        ov.empty() == false &&
        ov.size() == 6 &&
        ov.size() == ov.base().size() &&
        ov.front() == 'c' &&
        ov.front() == *ov.begin() &&
        ov.back() == 's' &&
        ov.back() == *(ov.end() - 1) &&
        ov.data() == ov.base()
    );
    std::cout << "sizeof(ov): " << sizeof ov << '\n' // typischerweise gleich sizeof(R)
              << "Range-basiert for: ";
    for (const char ch : ov)
        std::cout << ch;
    std::cout << '\n';
    std::ranges::owning_view<std::string> ov2;
    assert(ov2.empty());
//  ov2 = ov; // Kompilierfehler: Kopierzuweisungsoperator ist gelöscht
    ov2 = std::move(ov); // OK
    assert(ov2.size() == 6);
}

Mögliche Ausgabe: 

sizeof(ov): 32
range-for: cosmos

Siehe auch

(C++20)
eine view der Elemente eines anderen range
(Klassentemplate)
(C++20)
eine view die alle Elemente eines range enthält
(Alias-Template) (Range-Adapter-Objekt)