owning_view classe (libreria standard C++)

Visualizzazione che assume la proprietà degli elementi in un altro intervallo.

Sintassi

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

Parametri del modello

R
Tipo dell'intervallo sottostante.

Visualizzare le caratteristiche

Per una descrizione delle voci seguenti, vedere Visualizzare le caratteristiche della classe

Caratteristica	Descrizione
Adattatore di intervallo	views::all
Intervallo sottostante	Deve soddisfare input_range o superiore
Tipo di elemento	Uguale all'intervallo sottostante
Visualizzare la categoria iteratore	Uguale all'intervallo sottostante
Dimensioni	Solo se l'intervallo sottostante soddisfa sized_range
Iterabile const	Solo se l'intervallo sottostante soddisfa const-iterable
Intervallo comune	Solo se l'intervallo sottostante soddisfa common_range
Intervallo preso in prestito	Solo se l'intervallo sottostante soddisfa borrowed_range

Membri

Funzioni membro	Descrizione
Costruttori	Costruire un oggetto owning_view.
baseC++20	Ottenere un riferimento all'intervallo di proprietà.
beginC++20	Ottenere un iteratore al primo elemento.
dataC++20	Ottenere un puntatore al primo elemento.
emptyC++20	Verificare se la visualizzazione è vuota.
endC++20	Ottenere l'sentinel alla fine della visualizzazione.
sizeC++20	Ottiene il numero di elementi.
operator=	Assegnare (spostare) il contenuto da un altro owning_view a questo.
Ereditato da view_interface	Descrizione
backC++20	Ottiene l'ultimo elemento.
frontC++20	Ottenere il primo elemento.
operator[]C++20	Ottiene l'elemento nella posizione specificata.
operator boolC++20	Verificare se la visualizzazione non è vuota.

Osservazioni:

Il modo migliore per creare un owning_view oggetto consiste nell'usare l'adattatore views::all di intervallo. Gli adattatori di intervallo sono il modo previsto per creare classi di visualizzazione. I tipi di visualizzazione vengono esposti nel caso in cui si voglia creare un tipo di visualizzazione personalizzato.

Anche se questa classe possiede i propri elementi, non è costoso costruire perché l'intervallo sottostante viene spostato usando std::move().

Questa visualizzazione è utile quando si desidera un intervallo che non dipende dalla durata del contenitore che fornisce gli elementi.

Requisiti

Intestazione: <ranges> (da C++20)

Spazio dei nomi: std::ranges

Opzione del compilatore: /std:c++20 o versione successiva è obbligatoria.

Costruttori

Creare un'istanza di un 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

Parametri

rg
Intervallo da spostare nell'oggetto owning_view.

v
Oggetto owning_view da spostare nel nuovo owning_viewoggetto .

Per informazioni sui tipi di parametri del modello, vedere Parametri del modello.

Osservazioni:

1) Il costruttore predefinito crea un oggetto inizializzato owning_viewpredefinito.
2) Move costruisce l'oggetto owning_view da rg.
3) owning_view Un non può essere copiato, solo spostato.
4) Costruire l'oggetto owning_view da un altro owning_viewoggetto .

Esempio: 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

Ottiene un riferimento all'intervallo sottostante.

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

Parametri

Nessuna.

Valore restituito

Un riferimento all'intervallo sottostante, chiamarlo rg.
Per 1 & 2, l'intervallo sottostante viene restituito tramite return rg;
Per 3 & 4, l'intervallo sottostante viene restituito tramite std::move(rg);

begin

Ottiene un iteratore al primo elemento nella visualizzazione.

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

Parametri

Nessuna.

Valore restituito

Iteratore che punta al primo elemento nella visualizzazione:

data

Ottenere un puntatore al primo elemento nella visualizzazione.

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

Parametri

Nessuna.

Valore restituito

Puntatore al primo elemento nella visualizzazione.

Osservazioni:

L'intervallo di proprietà sottostante deve soddisfare contiguous_range.

empty

Verificare se la visualizzazione è vuota.

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

Parametri

Nessuna.

Valore restituito

Restituisce true se l'intervallo sottostante non dispone di elementi. In caso contrario, restituisce false.

end

Ottenere l'sentinel alla fine della visualizzazione.

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

Valore restituito

Sentinel che segue l'ultimo elemento nella visualizzazione:

size

Ottiene il numero di elementi nella visualizzazione.

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

Parametri

Nessuna.

Valore restituito

Numero di elementi nella visualizzazione.

operator=

Assegnare (spostare) il contenuto da un altro owning_view a questo.

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

Parametri

Oggetto owning_view da assegnare (spostare) a questo.

Valore restituito

*this

Osservazioni:

Un owning_view oggetto non può essere copiato, solo spostato.

Esempio: 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

Vedi anche

<ranges>
all adattatore di intervallo
classi di visualizzazione