Classe owning_view (Biblioteca Padrão C++)

Uma exibição que se apropria dos elementos em outro intervalo.

Sintaxe

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

Parâmetros de modelo

R
O tipo do intervalo subjacente.

Ver características

Para obter uma descrição das entradas a seguir, consulte Exibir características da classe

Característica	Descrição
Adaptador de gama	views::all
Intervalo subjacente	Deve satisfazer input_range ou superior
Tipo de elemento	O mesmo que o intervalo subjacente
Exibir categoria do iterador	O mesmo que o intervalo subjacente
Tamanho	Somente se o intervalo subjacente satisfizer sized_range
É const-iterável	Somente se o intervalo subjacente satisfizer const-iterable
Faixa comum	Somente se o intervalo subjacente satisfizer common_range
Alcance emprestado	Somente se o intervalo subjacente satisfizer borrowed_range

Membros

Funções de membro	Descrição
Construtores	Constrói um owning_view.
baseC++20	Obtenha uma referência ao intervalo de propriedade.
beginC++20	Obtenha um iterador para o primeiro elemento.
dataC++20	Obtenha um ponteiro para o primeiro elemento.
emptyC++20	Teste se a exibição está vazia.
endC++20	Pegue a sentinela no final da vista.
sizeC++20	Obtenha o número de elementos.
operator=	Atribua (mova) o conteúdo de outro owning_view para este.
Herdado de view_interface	Descrição
backC++20	Obtenha o último elemento.
frontC++20	Obtenha o primeiro elemento.
operator[]C++20	Obter o elemento na posição especificada.
operator boolC++20	Teste se a exibição não está vazia.

Comentários

A melhor maneira de criar um owning_view é usando o adaptador de views::all alcance. Os adaptadores de intervalo são a maneira pretendida de criar classes de exibição. Os tipos de exibição são expostos caso você queira criar seu próprio tipo de exibição personalizado.

Embora essa classe possua seus elementos, não é caro construí-la porque o intervalo subjacente é movido usando std::move().

Essa exibição é útil quando você deseja um intervalo que não dependa do tempo de vida do contêiner que fornece os elementos.

Requisitos

Cabeçalho: <ranges> (desde C++20)

Namespace: std::ranges

Opção do compilador: /std:c++20 ou posterior é necessária.

Construtores

Crie uma instância de uma 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

Parâmetros

rg
O intervalo para mover para o owning_view.

v
O owning_view para passar para o novo owning_view.

Para obter informações sobre tipos de parâmetro de modelo, consulte Parâmetros de modelo.

Comentários

1) O construtor padrão cria um owning_view.
2) Move constrói o owning_view de rg.
3) An owning_view não pode ser copiado, apenas movido.
4) Construa o owning_view de outro owning_view.

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

Obtém uma referência ao intervalo subjacente.

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

Parâmetros

Nenhum.

Valor retornado

Uma referência ao intervalo subjacente, chame-o rgde .
Para 1 e 2, o intervalo subjacente é retornado via return rg;
Para 3 e 4, o intervalo subjacente é retornado via std::move(rg);

begin

Obtenha um iterador para o primeiro elemento na exibição.

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

Parâmetros

Nenhum.

Valor retornado

Um iterador apontando para o primeiro elemento na exibição:

data

Obtenha um ponteiro para o primeiro elemento na exibição.

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

Parâmetros

Nenhum.

Valor retornado

Um ponteiro para o primeiro elemento na exibição.

Comentários

O intervalo de propriedade subjacente deve satisfazer contiguous_range.

empty

Teste se a exibição está vazia.

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

Parâmetros

Nenhum.

Valor retornado

Retorna true se o intervalo subjacente não tiver elementos. Caso contrário, retorna false.

end

Pegue a sentinela no final da vista.

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

Valor retornado

A sentinela que segue o último elemento na exibição:

size

Obtenha o número de elementos na exibição.

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

Parâmetros

Nenhum.

Valor retornado

O número de elementos na exibição.

operator=

Atribua (mova) o conteúdo de outro owning_view para este.

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

Parâmetros

O owning_view para atribuir (mover) a este.

Valor retornado

*this

Comentários

An owning_view não pode ser copiado, apenas movido.

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

Confira também

<ranges>
all adaptador de gama
Ver aulas