Freigeben über

owning_view Klasse (C++-Standardbibliothek)

  • Artikel

Eine Ansicht, die den Besitz der Elemente in einem anderen Bereich übernimmt.

Syntax

template<range R>
    requires std::movable<R> && (!is-initializer-list<R>)
class owning_view : public ranges::view_interface<owning_view<R>>;

Vorlagenparameter

R
Der Typ des zugrunde liegenden Bereichs.

Eigenschaften der Ansicht

Eine Beschreibung der folgenden Einträge finden Sie unter Anzeigen von Klassenmerkmalen

Merkmal Beschreibung
Range Adaptor views::all
Zugrunde liegender Bereich Muss erfüllen input_range oder höher
Elementtyp Identisch mit dem zugrunde liegenden Bereich
Iteratorkategorie anzeigen Identisch mit dem zugrunde liegenden Bereich
Größer eingestellt Nur, wenn der zugrunde liegende Bereich erfüllt ist sized_range
Ist const-iterierbar Nur, wenn der zugrunde liegende Bereich erfüllt ist const-iterable
Allgemeiner Bereich Nur, wenn der zugrunde liegende Bereich erfüllt ist common_range
Geliehener Bereich Nur, wenn der zugrunde liegende Bereich erfüllt ist borrowed_range

Member

Memberfunktionen Beschreibung
Konstruktoren Erstellen eines owning_view.
baseC++20 Rufen Sie einen Verweis auf den besitzeigenen Bereich ab.
beginC++20 Rufen Sie einen Iterator zum ersten Element ab.
dataC++20 Rufen Sie einen Zeiger auf das erste Element ab.
emptyC++20 Testen Sie, ob die Ansicht leer ist.
endC++20 Rufen Sie den Sentinel am Ende der Ansicht ab.
sizeC++20 Ruft die Anzahl der Elemente ab.
operator= Weisen Sie den Inhalt von einem anderen owning_view zu dieser Zuweisung zu (verschieben).
Geerbt von view_interface Beschreibung
backC++20 Rufen Sie das letzte Element ab.
frontC++20 Rufen Sie das erste Element ab.
operator[]C++20 Rufen Sie das Element an der angegebenen Position ab.
operator boolC++20 Testen Sie, ob die Ansicht nicht leer ist.

Hinweise

Die beste Methode zum Erstellen eines Elements owning_view ist die Verwendung des views::all Bereichsadapters. Bereichsadapter sind die beabsichtigte Möglichkeit zum Erstellen von Ansichtsklassen. Die Ansichtstypen werden für den Fall verfügbar gemacht, dass Sie ihren eigenen benutzerdefinierten Ansichtstyp erstellen möchten.

Obwohl diese Klasse ihre Elemente besitzt, ist es nicht teuer zu konstruieren, da der zugrunde liegende Bereich mit std::move()verschoben wird.

Diese Ansicht ist nützlich, wenn Sie einen Bereich benötigen, der nicht von der Lebensdauer des Containers abhängt, der die Elemente bereitstellt.

Anforderungen

Header: <ranges> (seit C++20)

Namespace:std::ranges

Compileroption: /std:c++20 oder höher ist erforderlich.

Konstruktoren

Erstellen Sie eine Instanz von owning_view.

1) owning_view() requires default_initializable<R> = default;
2) constexpr owning_view(R&& rg); 
3) owning_view(const owning_view& v) = delete; // no copy constructor 
4) owning_view(const owning_view&& v) = default; // move constructor

Parameter

rg
Der Bereich, der in den owning_viewBereich verschoben werden soll.

v
Der owning_view Umstieg auf das neue owning_view.

Informationen zu Vorlagenparametertypen finden Sie unter Vorlagenparameter.

Hinweise

1) Der Standardkonstruktor erstellt einen standardinitialisierten owning_view.
2) Verschieben von Konstrukten aus owning_view rg.
3) Eine owning_view kann nicht kopiert werden, nur verschoben.
4) Erstellen Sie das owning_view aus einem anderen owning_view.

Beispiel: owning_view

// requires /std:c++20 or later
#include <ranges>
#include <iostream>
#include <vector>
#include <utility>

int main()
{
    std::vector<int> v = {1,2,3,4,5,6,7,8,9,10};
    auto myOwningView = std::views::all(std::move(v)); // create an owning_view from a moved vector
    std::cout << v.size() << '\n'; // outputs 0 because myOwningView now owns the elements
    std::cout << myOwningView.size() << '\n'; // outputs 10

    std::vector<int> v2 = {1,2,3,4,5};
    std::ranges::owning_view<std::vector<int>> ov2{std::move(v2)};
    std::cout << v2.size() << '\n'; // outputs 0 because ov2 now owns the elements
    std::cout << ov2.size() << '\n'; // outputs 5
}

0
10
0
5

base

Ruft einen Verweis auf den zugrunde liegenden Bereich ab.

1) constexpr R& base() & noexcept { return r_; }
2) constexpr const R& base() const & noexcept { return r_; }
3) constexpr R&& base() && noexcept { return std::move(r_); }
4) constexpr const R&& base() const && noexcept { return std::move(r_); }

Parameter

Keine

Rückgabewert

Ein Verweis auf den zugrunde liegenden Bereich, rufen Sie ihn rgauf.
Für 1 & 2 wird der zugrunde liegende Bereich über return rg;
Für 3 & 4 wird der zugrunde liegende Bereich über std::move(rg);

begin

Rufen Sie einen Iterator zum ersten Element in der Ansicht ab.

constexpr iterator_t<R> begin();
constexpr auto begin() const requires range<const R>;

Parameter

Keine

Rückgabewert

Ein Iterator, der auf das erste Element in der Ansicht zeigt:

Abbildung eines Vektors mit den Elementen 10, 20 und 30. Das erste Element enthält 10 und ist mit

data

Rufen Sie einen Zeiger auf das erste Element in der Ansicht ab.

constexpr auto data()
    requires std::contiguous_iterator<ranges::iterator_t<R>>;
constexpr auto data() const
    requires std::contiguous_iterator<ranges::iterator_t<const R>>;

Parameter

Keine

Rückgabewert

Ein Zeiger auf das erste Element in der Ansicht.

Hinweise

Der zugrunde liegende Bereich muss erfüllt sein contiguous_range.

empty

Testen Sie, ob die Ansicht leer ist.

constexpr bool empty();
constexpr bool empty() const;

Parameter

Keine

Rückgabewert

Gibt zurück true , wenn der zugrunde liegende Bereich keine Elemente enthält. Andernfalls wird falsezurückgegeben.

end

Rufen Sie den Sentinel am Ende der Ansicht ab.

constexpr sentinel_t<R> end();
constexpr auto end() const requires range<const R>

Rückgabewert

Der Sentinel, der auf das letzte Element in der Ansicht folgt:

Abbildung eines Vektors mit den Elementen 10, 20 und 30. Das erste Element enthält 10 und ist mit

size

Ruft die Anzahl der Elemente in der Ansicht ab.

constexpr auto size() requires ranges::sized_range<R>;
constexpr auto size() const requires ranges::sized_range<const R>;

Parameter

Keine

Rückgabewert

Die Anzahl der Elemente in der Ansicht.

operator=

Weisen Sie den Inhalt von einem anderen owning_view zu dieser Zuweisung zu (verschieben).

owning_view& operator=(owning_view&&) = default;

Parameter

The owning_view to assign (move) to this one.

Rückgabewert

*this

Bemerkungen

Eine owning_view Datei kann nicht kopiert werden, nur verschoben.

Beispiel: operator=

// requires /std:c++20 or later
#include <ranges>
#include <iostream>
#include <vector>

int main()
{
    std::vector<int> v1 = {1,2,3};
    std::ranges::owning_view<std::vector<int>> ov1{std::move(v1)};
    
    std::vector<int> v2 = {4,5,6};
    std::ranges::owning_view<std::vector<int>> ov2{std::move(v2)};
    
    // operator=
    ov2 = std::move(ov1);

    // ov1 took ownership of v1, so v1 is empty
    // ov2 took ownership of v2, so v2 is empty
    // ov2 then took ownership of ov1, so ov1 is empty
    // ov2 now owns the elements 1, 2, 3

    std::cout << std::boolalpha << "v1.empty():" << v1.empty() << " ov1.empty():" << ov1.empty() << '\n'; // v1.empty():true ov1.empty():true
    std::cout << "v2.empty():" << v2.empty() << " ov2.size():" << ov2.size() << '\n'; // v2.empty():true ov2.size():3

    for (auto e : ov2)
    {
         std::cout << e << ' '; // 1 2 3
    }
}

v1.empty():true ov1.empty():true
v2.empty():true ov2.size():3
1 2 3

Siehe auch

<ranges>
all Range Adaptor
Anzeigen von Klassen