std::ranges::owning_view

 

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

 

Bereichsbibliothek

Bereichszugriff begin cbegin   end cend rbegin crbegin   rend crend size ssize   data cdata reserve_hint (C++26)   empty

Range-Konvertierungen std::from_range_t std::from_range (C++23)(C++23)     to (C++23)

Behandlung von hängenden Iteratoren dangling borrowed_iterator_t borrowed_subrange_t

Range-Primitive
range_size_trange_difference_trange_value_t elements_of (C++23)	iterator_tconst_iterator_tsentinel_tconst_sentinel_t (C++23)(C++23)	range_reference_trange_const_reference_trange_rvalue_reference_trange_common_reference_t (C++23)

Range-Konzepte
range borrowed_range    common_range	sized_range viewable_range    view	input_range output_range forward_range	bidirectional_range    random_access_range contiguous_range	approximately_sized_range (C++26) constant_range (C++23)

Ansichten
view_interface	subrange

Range-Fabriken
empty_viewviews::empty	single_viewviews::single	basic_istream_viewviews::istream	iota_viewviews::iota	repeat_viewviews::repeat (C++23)(C++23)

Range-Adaptoren
views::all_tviews::all as_rvalue_viewviews::as_rvalue (C++23)(C++23)   filter_viewviews::filter transform_viewviews::transform take_viewviews::take take_while_viewviews::take_while common_viewviews::common views::counted to_input_viewviews::to_input (C++26)(C++26)	ref_view drop_viewviews::drop drop_while_viewviews::drop_while lazy_split_viewviews::lazy_split split_viewviews::split join_viewviews::join join_with_viewviews::join_with (C++23)(C++23)   concat_viewviews::concat (C++26)(C++26) cache_latest_viewviews::cache_latest (C++26)(C++26)	owning_view reverse_viewviews::reverse as_const_viewviews::as_const (C++23)(C++23) elements_viewviews::elements keys_viewviews::keys values_viewviews::values enumerate_viewviews::enumerate (C++23)(C++23) zip_viewviews::zip (C++23)(C++23) zip_transform_viewviews::zip_transform (C++23)(C++23)	adjacent_viewviews::adjacent (C++23)(C++23) views::pairwise (C++23) adjacent_transform_viewviews::adjacent_transform (C++23)(C++23) views::pairwise_transform (C++23) chunk_viewviews::chunk (C++23)(C++23) slide_viewviews::slide (C++23)(C++23) chunk_by_viewviews::chunk_by (C++23)(C++23) stride_viewviews::stride (C++23)(C++23) cartesian_product_viewviews::cartesian_product (C++23)(C++23)

Range generators std::generator (C++23)

Range-Adaptor-Closure-Objekte range_adaptor_closure (C++23)

Range-Adaptor-Objekte

Hilfselemente
copyable-box movable-box (bis C++23)  (C++23)	simple-view non-propagating-cache

 

Definiert in der Header-Datei <ranges>
template< ranges::range R >     erfordert 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 das alleinige Eigentum an einem range besitzt. Sie ist nur verschiebbar und speichert diesen range darin.

Der konstante Ausdruck /*is-initializer-list*/<R> in der Er-Klausel ist true genau dann, wenn std::remove_cvref_t<R> eine Spezialisierung von std::initializer_list ist.

Datenelemente

Member-Name	Definition
r_ (private)	Der zugrundeliegende Range vom Typ R. ((exposition-only member object*)

Memberfunktionen

(Konstruktor)	konstruiert eine owning_view durch Wertinitialisierung oder Verschiebekonstruktion des gespeicherten Ranges (öffentliche Memberfunktion)
operator=	verschiebt den gespeicherten Range (öffentliche Memberfunktion)
base	gibt eine Referenz auf den gespeicherten Range zurück (öffentliche Memberfunktion)
begin	gibt den Anfangs-Iterator des gespeicherten Ranges zurück (öffentliche Memberfunktion)
end	gibt das Sentinel des gespeicherten Ranges zurück (öffentliche Memberfunktion)
empty	prüft, ob der gespeicherte Range leer ist (öffentliche Memberfunktion)
size	gibt die Größe des gespeicherten sized_range zurück (öffentliche Memberfunktion)
data	gibt den Zeiger auf den Anfang des gespeicherten contiguous_range zurück (öffentliche Memberfunktion)
Geerbt von std::ranges::view_interface
cbegin (C++23)	gibt einen konstanten Iterator zum Anfang des Bereichs zurück (public member function of std::ranges::view_interface<D>)
cend (C++23)	gibt ein Sentinel für den konstanten Iterator des Bereichs zurück (public member function of std::ranges::view_interface<D>)
operator bool	gibt zurück, ob die abgeleitete Ansicht nicht leer ist, bereitgestellt nur, wenn ranges::empty darauf anwendbar ist (public member function of std::ranges::view_interface<D>)
front	gibt das erste Element in der abgeleiteten View zurück, bereitgestellt, wenn sie forward_range erfüllt (öffentliche Member-Funktion von std::ranges::view_interface<D>)
back	gibt das letzte Element in der abgeleiteten View zurück, nur bereitgestellt, wenn sie bidirectional_range und common_range erfüllt (öffentliche Member-Funktion von std::ranges::view_interface<D>)
operator[]	gibt das n-te Element in der abgeleiteten View zurück, nur bereitgestellt, wenn sie random_access_range erfüllt (öffentliche Member-Funktion von std::ranges::view_interface<D>)

std::ranges::owning_view::owning_view

owning_view() erfordert 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)
owning_view( const owning_view& ) = delete;	(4)	(seit C++20)

1) Standardkonstruktor. Initialisiert den gespeicherten Range per Wert durch seine Standardmember-Initialisierung (= R()).

2) Verschiebekonstruktor. Erstellt den gespeicherten Range durch Verschieben aus dem von other.

3) Erstellt den gespeicherten Range durch Verschieben aus t.

4) Kopierkonstruktor ist gelöscht. owning_view ist nur verschiebbar.

Parameter

Sonstiges	-	eine weitere owning_view zum Verschieben aus
t	-	Range zum Verschieben aus

std::ranges::owning_view::operator=

owning_view& operator=( owning_view&& other ) = default;	(1)	(seit C++20)
owning_view& operator=( const owning_view& ) = delete;	(2)	(seit C++20)

1) Zuweisungsoperator für das Verschieben. Verschiebt den gespeicherten Range aus dem von other.

2) Zuweisungsoperator für das Kopieren ist gelöscht. owning_view ist nur verschiebbar.

Parameter

Sonstiges

-

eine weitere owning_view zum Verschieben aus

Rückgabewert

*this

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 Range zurück, wobei die Wertkategorie und die const-Qualifikation beibehalten werden.

1,2) Entspricht return r_;.

3,4) Entspricht return 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)

Entspricht return ranges::begin(r_);.

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)

Entspricht return ranges::end(r_);.

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)

Entspricht return ranges::empty(r_);.

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)

Entspricht return ranges::size(r_);.

std::ranges::owning_view::data

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

Entspricht return ranges::data(r_);.

Hilfsschablonen

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 lässt owning_view borrowed_range erfüllen, wenn der zugrundeliegende Range dies tut.

Beispiel

Führen Sie diesen Code aus

#include <cassert>
#include <iostream>
#include <ranges>
#include <string>
 
int main()
{
    using namespace std::literals;
    std::ranges::owning_view ov{"cosmos"s}; // the deduced type of R is std::string;
                                            // `ov` is the only owner of this string
    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' // typically equal to sizeof(R)
              << "range-for: ";
    for (const char ch : ov)
        std::cout << ch;
    std::cout << '\n';
 
    std::ranges::owning_view<std::string> ov2;
    assert(ov2.empty());
//  ov2 = ov; // compile-time error: copy assignment operator is deleted
    ov2 = std::move(ov); // OK
    assert(ov2.size() == 6);
}

Mögliche Ausgabe

sizeof(ov): 32
range-for: cosmos

Siehe auch

ranges::ref_view (C++20)	ein view der Elemente eines anderen range (Klassen-Template)
views::all_tviews::all (C++20)	ein view, der alle Elemente eines range enthält (Alias-Template) (Range-Adaptor-Objekt)