Envoltorio copiable (C++20)

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos (C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación (C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos (C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos (C++17)

Biblioteca de apoyo de concurrencia (C++11)

Biblioteca de apoyo de ejecución (C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Biblioteca de rangos

Acceso a rangos begin cbegin   end cend rbegin crbegin   rend crend size ssize   data cdata empty

Conversiones de rangos std::from_range_t std::from_range (C++23)(C++23)     to (C++23)

Manejo de iteradores pendientes dangling borrowed_iterator_t borrowed_subrange_t

Primitivas de rangos
range_size_trange_difference_trange_value_t elements_of (C++23)	iterator_tconst_iterator_tsentinel_tconst_sentinel_t (C++23)(C++23)	range_reference_trange_const_reference_trange_rvalue_reference_trange_common_reference_t (C++23)

Conceptos de rangos
range borrowed_range    sized_range	common_range view viewable_range	input_range output_range forward_range	bidirectional_range    random_access_range contiguous_range	constant_range (C++23)

Vistas
view_interface	subrange

Fábricas de rangos
empty_viewviews::empty	single_viewviews::single	basic_istream_viewviews::istream	iota_viewviews::iota	repeat_viewviews::repeat (C++23)(C++23)

Adaptadores de rangos
views::all_tviews::all ref_view owning_view as_rvalue_viewviews::as_rvalue (C++23)(C++23)   filter_viewviews::filter transform_viewviews::transform take_viewviews::take take_while_viewviews::take_while concat_viewviews::concat (C++26)(C++26) views::counted	drop_viewviews::drop drop_while_viewviews::drop_while join_viewviews::join join_with_viewviews::join_with (C++23)(C++23)   lazy_split_viewviews::lazy_split split_viewviews::split common_viewviews::common cache_latest_viewviews::cache_latest (C++26)(C++26)	reverse_viewviews::reverse as_const_viewviews::as_const (C++23)(C++23) elements_viewviews::elements keys_viewviews::keys values_viewviews::values enumerate_viewviews::enumerate (C++23)(C++23) zip_viewviews::zip (C++23)(C++23) zip_transform_viewviews::zip_transform (C++23)(C++23)	adjacent_viewviews::adjacent (C++23)(C++23) views::pairwise (C++23) adjacent_transform_viewviews::adjacent_transform (C++23)(C++23) views::pairwise_transform (C++23) chunk_viewviews::chunk (C++23)(C++23) slide_viewviews::slide (C++23)(C++23) chunk_by_viewviews::chunk_by (C++23)(C++23) stride_viewviews::stride (C++23)(C++23) cartesian_product_viewviews::cartesian_product (C++23)(C++23)

Generadores de rangos std::generator (C++23)

Objetos cierre adaptadores de rangos range_adaptor_closure (C++23)

Objetos adaptadores de rangos

Elementos auxiliares
copyable-box movable-box (hasta C++23)  (C++23)	simple-view non-propagating-cache

 

<tbody> </tbody>

template<class T> requires std::copy_constructible<T> && std::is_object_v<T> class /*copyable-box*/;		(desde C++20)

See More

ranges::single_view y los adaptadores de rango que almacenan un objeto invocable se especifican en términos de una plantilla de clase solo de exposición copyable-box (envoltorio copiable). El nombre copyable-box es solo para fines de exposición.

/*copyable-box*/<T> se comporta exactamente como std::optional<T>, excepto que el constructor por defecto, el operador de asignación de copia y el operador de asignación de movimiento son (condicionalmente) diferentes de los de std::optional, lo que hace que siempre satisfaga copyable.

Si T ya es copyable, o tanto std::is_nothrow_move_constructible_v<T> como std::is_nothrow_copy_constructible_v<T> son true, /*copyable-box*/<T> solo puede almacenar un objeto T, ya que siempre contiene un valor.

Parámetros de plantilla

T

-

El tipo del valor contenido, debe ser un tipo objeto que modele copy_constructible.

Funciones miembro

copyable-box::copyable-box

<tbody> </tbody>

constexpr /*copyable-box*/() noexcept(std::is_nothrow_default_constructible_v<T>) requires std::default_initializable<T> : /*copyable-box*/(std::in_place) { }		(desde C++20)

El constructor por defecto se proporciona si y solo si T modela default_initializable.

Un objeto /*copyable-box*/<T> construido por defecto contiene un objeto T inicializado por valor.

copyable-box::operator=

<tbody> </tbody>

constexpr /*copyable-box*/& operator=(const /*copyable-box*/& other); noexcept(/* véase a continuación */);	(1)	(desde C++20)
constexpr /*copyable-box*/& operator=(/*copyable-box*/&& other) noexcept(std::is_nothrow_move_constructible_v<T>);	(2)	(desde C++20)

1) Si std::copyable<T> no está modelado, el operador de asignación de copia se define de manera equivalente como:

constexpr /*copyable-box*/& operator=(const /*copyable-box*/& other) noexcept(std::is_nothrow_copy_constructible_v<T>) { if (this != std::addressof(other)) { if (other) emplace(*other); else reset(); } return *this; }

De lo contrario, es idéntico a el operador de asignación de copia de std::optional.

2) Si std::movable<T> no está modelado, el operador de asignación de movimiento se define de manera equivalente como:

constexpr /*copyable-box*/& operator=(/*copyable-box*/&& other) noexcept(std::is_nothrow_move_constructible_v<T>) { if (this != std::addressof(other)) { if (other) emplace(std::move(*other)); else reset(); } return *this; }

De lo contrario, es idéntico a el operador de asignación de movimiento de std::optional.

Miembros identicos a std::optional

Funciones miembro

(constructor)	Construye el objeto opcional. (función miembro pública de std::optional<T>)
(destructor)	Destruye el valor contenido, si es que lo hay. (función miembro pública de std::optional<T>)
operator=	Asigna contenido. (función miembro pública de std::optional<T>)
Observadores
operator->operator*	Accede al valor contenido. (función miembro pública de std::optional<T>)
operator boolhas_value	Comprueba si un objeto opcional contiene un valor. (función miembro pública de std::optional<T>)
Modificadores
reset	Destruye cualquier valor contenido. (función miembro pública de std::optional<T>)
emplace	Construye el valor contenido en el sitio. (función miembro pública de std::optional<T>)

Notas

Un objeto copyable-box no contiene un valor solo si

• T no modela movable o copyable, y se genera una excepción en la asignación de movimiento o la asignación de copia respectivamente, o
• se inicializa/asigna desde otro envoltorio sin valor.

Antes de P2325R3, el contenedor se llamaba semiregular-box en el estándar y siempre cumplía con semiregular, ya que siempre se proporcionaba el constructor por defecto (que podría construir un envoltorio sin valor).

Informes de defectos

Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.

ID	Aplicado a	Comportamiento según lo publicado	Comportamiento correcto
P2325R3	C++20	Si T no es default_initializable, el constructor por defecto construye un contenedor que no contiene un valor.	El envoltorio tampoco es default_initializable.
LWG 3572	C++20	Los operadores de asignación condicionalmente diferentes no eran constexpr.	Se hicieron constexpr.

Véase también

ranges::single_viewviews::single (C++20)	Una vista (view) que contiene un solo elemento de un valor específico. (plantilla de clase) (objeto punto de personalización)
ranges::filter_viewviews::filter (C++20)	Una vista (view) que consiste en los elementos de un rango (range) que satisface un predicado. (plantilla de clase) (objeto adaptador de rango)
ranges::transform_viewviews::transform (C++20)	Una vista (view) de una secuencia que aplica una función de transformación a cada elemento. (plantilla de clase) (objeto adaptador de rango)
ranges::take_while_viewviews::take_while (C++20)	Una vista (view) que consiste en los elementos iniciales de otra vista, hasta el primer elemento sobre el que un predicado devuelva falso. (plantilla de clase) (objeto adaptador de rango)
ranges::drop_while_viewviews::drop_while (C++20)	Una vista (view) que consiste en los elementos de otra vista, saltándose la subsecuencia inicial de elementos hasta el primer elemento donde el predicado devuelva falso. (plantilla de clase) (objeto adaptador de rango)
ranges::zip_transform_viewviews::zip_transform (C++23)	Una vista (view) que consiste en tuplas del resultado de aplicar una función de transformación a los elementos correspondientes de las vistas adaptadas. (plantilla de clase) (objeto punto de personalización)
ranges::adjacent_transform_viewviews::adjacent_transform (C++23)	Una vista (vista) que consiste en tuplas del resultado de aplicar una función de transformación a elementos adyacentes de la vista adaptada. (plantilla de clase) (objeto adaptador de rango)