owning_view class (Standardowa biblioteka C++)

Widok, który przejmuje własność elementów w innym zakresie.

Składnia

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

Parametry szablonu

R
Typ bazowego zakresu.

Właściwości widoku

Opis poniższych wpisów można znaleźć w temacie View class characteristics (Wyświetlanie właściwości klas)

Characteristic	opis
Adapter zakresu	views::all
Zakres bazowy	Musi spełniać input_range lub wyższe
Typ elementu	Taki sam jak zakres bazowy
Wyświetl kategorię iteratora	Taki sam jak zakres bazowy
Wielkości	Tylko wtedy, gdy zakres bazowy spełnia sized_range
Jest constiterowalne	Tylko wtedy, gdy zakres bazowy spełnia const-iterable
Wspólny zakres	Tylko wtedy, gdy zakres bazowy spełnia common_range
Pożyczony zakres	Tylko wtedy, gdy zakres bazowy spełnia borrowed_range

Elementy członkowskie

Funkcje składowe	Opis
Konstruktory	Skonstruuj element owning_view.
baseC++20	Uzyskaj odwołanie do należącego zakresu.
beginC++20	Pobierz iterator do pierwszego elementu.
dataC++20	Pobierz wskaźnik do pierwszego elementu.
emptyC++20	Sprawdź, czy widok jest pusty.
endC++20	Pobierz element sentinel na końcu widoku.
sizeC++20	Pobierz liczbę elementów.
operator=	Przypisz (przenieś) zawartość z innej owning_view do tej.
Dziedziczone z view_interface	Opis
backC++20	Pobierz ostatni element.
frontC++20	Pobierz pierwszy element.
operator[]C++20	Pobierz element na określonej pozycji.
operator boolC++20	Sprawdź, czy widok nie jest pusty.

Uwagi

Najlepszym sposobem utworzenia elementu owning_view jest użycie adaptera views::all zakresu. Adaptery zakresów są zamierzonym sposobem tworzenia klas widoków. Typy widoków są widoczne w przypadku utworzenia własnego niestandardowego typu widoku.

Mimo że ta klasa jest właścicielem swoich elementów, nie jest kosztowna do skonstruowania, ponieważ bazowy zakres jest przenoszony przy użyciu klasy std::move().

Ten widok jest przydatny, gdy chcesz, aby zakres, który nie zależy od okresu istnienia kontenera dostarczającego elementy.

Wymagania

Nagłówek: <ranges> (od C++20)

Przestrzeń nazw: std::ranges

Opcja kompilatora: /std:c++20 lub nowsza jest wymagana.

Konstruktory

Utwórz wystąpienie klasy 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

Parametry

rg
Zakres do przejścia do .owning_view

v
Polecenie owning_view , aby przejść do nowego owning_viewelementu .

Aby uzyskać informacje o typach parametrów szablonu, zobacz Parametry szablonu.

Uwagi

1) Domyślny konstruktor tworzy inicjowany owning_viewdomyślnie .
2) Przeniesienie konstruuje element owning_view z rg.
3) owning_view Nie można skopiować, tylko przenieść.
4) Skonstruuj element owning_view z innego owning_viewelementu .

Przykład: 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

Pobiera odwołanie do bazowego zakresu.

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_); }

Parametry

Brak.

Wartość zwracana

Wywołaj odwołanie do bazowego zakresu rg.
W przypadku wartości 1 i 2 podstawowy zakres jest zwracany za pośrednictwem return rg;
W przypadku wartości 3 i 4 zakres bazowy jest zwracany za pośrednictwem std::move(rg);

begin

Pobierz iterator do pierwszego elementu w widoku.

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

Parametry

Brak.

Wartość zwracana

Iterator wskazujący pierwszy element w widoku:

data

Pobierz wskaźnik do pierwszego elementu w widoku.

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

Parametry

Brak.

Wartość zwracana

Wskaźnik do pierwszego elementu w widoku.

Uwagi

Podstawowy zakres własności musi spełniać wartość contiguous_range.

empty

Sprawdź, czy widok jest pusty.

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

Parametry

Brak.

Wartość zwracana

Zwraca wartość true , jeśli zakres bazowy nie zawiera żadnych elementów. W przeciwnym razie zwraca wartość false.

end

Pobierz element sentinel na końcu widoku.

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

Wartość zwracana

Sentinel, który jest zgodny z ostatnim elementem w widoku:

size

Pobierz liczbę elementów w widoku.

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

Parametry

Brak.

Wartość zwracana

Liczba elementów w widoku.

operator=

Przypisz (przenieś) zawartość z innej owning_view do tej.

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

Parametry

Element owning_view do przypisania (przenieś) do tego.

Wartość zwracana

*this

Uwagi

owning_view Nie można skopiować elementu, tylko przenieść.

Przykład: 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

Zobacz też

<ranges>
all adapter zakresu
klasy widoków