owning_view (Clase, Biblioteca estándar de C++)
Vista que toma posesión de los elementos de otro intervalo.
Sintaxis
template<range R>
requires std::movable<R> && (!is-initializer-list<R>)
class owning_view : public ranges::view_interface<owning_view<R>>;
Parámetros de plantilla
R
Tipo del intervalo subyacente.
Características de la vista
Para obtener una descripción de las siguientes entradas, vea View class characteristics (Ver características de clase).
| Característica | Descripción |
|---|---|
| Adaptador de rango | views::all |
| Intervalo subyacente | Debe satisfacer input_range o superior |
| Tipo de elemento | Igual que el intervalo subyacente |
| Ver categoría de iterador | Igual que el intervalo subyacente |
| Tamaño | Solo si el intervalo subyacente cumple sized_range |
Es const-iterable |
Solo si el intervalo subyacente cumple const-iterable |
| Rango común | Solo si el intervalo subyacente cumple common_range |
| Intervalo prestado | Solo si el intervalo subyacente cumple borrowed_range |
Miembros
| Funciones miembro | Descripción |
|---|---|
| Constructores | Construcción de un owning_view. |
baseC++20 |
Obtenga una referencia al intervalo de propiedad. |
beginC++20 |
Obtenga un iterador al primer elemento. |
dataC++20 |
Obtiene un puntero al primer elemento. |
emptyC++20 |
Compruebe si la vista está vacía. |
endC++20 |
Obtenga el sentinel al final de la vista. |
sizeC++20 |
Obtiene el número de elementos. |
operator= |
Asigne (mueva) el contenido de otro owning_view a este. |
Heredado de view_interface |
Descripción |
backC++20 |
Obtenga el último elemento. |
frontC++20 |
Obtiene el primer elemento. |
operator[]C++20 |
Obtiene el elemento que se encuentra en la posición especificada. |
operator boolC++20 |
Compruebe si la vista no está vacía. |
Comentarios
La mejor manera de crear un owning_view es usar el adaptador de views::all rango. Los adaptadores de rango son la manera prevista de crear clases de vista. Los tipos de vista se exponen en caso de que desee crear su propio tipo de vista personalizado.
Aunque esta clase posee sus elementos, no es costoso construir porque el intervalo subyacente se mueve mediante std::move().
Esta vista es útil cuando se desea un intervalo que no depende de la duración del contenedor que proporciona los elementos.
Requisitos
Encabezado: <ranges> (desde C++20)
Espacio de nombres: std::ranges
Opción del compilador: /std:c++20 o posterior es necesaria.
Constructores
Cree una instancia de 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
Intervalo que se va a mover a .owning_view
v
que owning_view se va a mover al nuevo owning_view.
Para obtener información sobre los tipos de parámetros de plantilla, consulte Parámetros de plantilla.
Comentarios
1) El constructor predeterminado crea un valor inicializado owning_viewde forma predeterminada.
2) Move construye desde owning_view rg.
3) No owning_view se puede copiar, solo se puede mover.
4) Construir a owning_view partir de otro owning_view.
Ejemplo: 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
Obtiene una referencia al intervalo subyacente.
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
Ninguno.
Valor devuelto
Una referencia al intervalo subyacente, llámela rg.
Para 1 y 2, el rango subyacente se devuelve a través de return rg;
Para 3 y 4, el rango subyacente se devuelve a través de std::move(rg);
begin
Obtenga un iterador al primer elemento de la vista.
constexpr iterator_t<R> begin();
constexpr auto begin() const requires range<const R>;
Parámetros
Ninguno.
Valor devuelto
Iterador que apunta al primer elemento de la vista:
data
Obtenga un puntero al primer elemento de la vista.
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
Ninguno.
Valor devuelto
Puntero al primer elemento de la vista.
Comentarios
El intervalo de propiedad subyacente debe satisfacer contiguous_range.
empty
Compruebe si la vista está vacía.
constexpr bool empty();
constexpr bool empty() const;
Parámetros
Ninguno.
Valor devuelto
Devuelve true si el intervalo subyacente no tiene elementos. De lo contrario, devuelve false.
end
Obtenga el sentinel al final de la vista.
constexpr sentinel_t<R> end();
constexpr auto end() const requires range<const R>
Valor devuelto
Sentinel que sigue al último elemento de la vista:
size
Obtiene el número de elementos de la vista.
constexpr auto size() requires ranges::sized_range<R>;
constexpr auto size() const requires ranges::sized_range<const R>;
Parámetros
Ninguno.
Valor devuelto
Número de elementos de la vista.
operator=
Asigne (mueva) el contenido de otro owning_view a este.
owning_view& operator=(owning_view&&) = default;
Parámetros
que owning_view se va a asignar (mover) a este.
Valor devuelto
*this
Comentarios
owning_view No se puede copiar , solo se puede mover.
Ejemplo: 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