Namespaces
Variants

Assignable wrapper (C++20)

From cppreference.net
C++
Ranges library
Range adaptors
Helper items
copyable-box
movable-box
(until C++23) (C++23)


template < class T >

requires std:: copy_constructible < T > && std:: is_object_v < T >

class /*copyable-box*/ ;
(desde C++20)
(hasta C++23)
( solo para exposición* )
template < class T >

requires std:: move_constructible < T > && std:: is_object_v < T >

class /*movable-box*/ ;
(desde C++23)
( solo para exposición* )

ranges::single_view , ranges::repeat_view , (desde C++23) y los adaptadores de rango que almacenan un objeto invocable se especifican en términos de una plantilla de clase solo para exposición copyable-box (hasta C++23) movable-box (desde C++23) . El nombre mostrado aquí es solo para fines de exposición.

El contenedor 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 cual aumenta T con capacidad de asignación cuando es necesario y hace que siempre satisfaga copyable o movable (desde C++23) .

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 > puede almacenar solo un objeto T , porque siempre contiene un valor.

(hasta C++23)

Si T

/*movable-box*/ < T > puede almacenar solo un objeto T , porque siempre contiene un valor.

(desde C++23)

Contenidos

Parámetros de plantilla

T - el tipo del valor contenido, debe ser un tipo de objeto que modele copy_constructible (hasta C++23) move_constructible (desde C++23)

Funciones miembro

Constructor por defecto

constexpr /*copyable-box*/ ( ) noexcept ( std:: is_nothrow_default_constructible_v < T > )

requires std:: default_initializable < T >

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

requires std:: default_initializable < T >

: /*movable-box*/ ( std:: in_place ) { }
(desde C++23)

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

Un wrapper construido por defecto contiene un objeto T inicializado por valor.

Operadores de asignación

(1)
constexpr /*copyable-box*/ & operator = ( const /*copyable-box*/ & other ) ;
noexcept ( /* ver abajo */ ) ;
(desde C++20)
(hasta C++23)
constexpr /*movable-box*/ & operator = ( const /*movable-box*/ & other ) ;
noexcept ( /* ver abajo */ ) requires std:: copy_constructible < T > ;
(desde C++23)
(2)
constexpr /*copyable-box*/ & operator = ( /*copyable-box*/ && other )
noexcept ( std:: is_nothrow_move_constructible_v < T > ) ;
(desde C++20)
(hasta C++23)
constexpr /*movable-box*/ & operator = ( /*movable-box*/ && other )
noexcept ( std:: is_nothrow_move_constructible_v < T > ) ;
(desde C++23)
1) Si std:: copyable < T > no se modela, el operador de asignación de copia se define equivalentemente 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 ;
}

(hasta C++23)

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

return * this ;
}

(desde C++23)
De lo contrario, es idéntico a el operador de asignación de copia de std::optional .
2) Si std:: movable < T > no se modela, el operador de asignación de movimiento se define equivalentemente 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 ;
}

(hasta C++23)

constexpr /*movable-box*/ & operator = ( /*movable-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 ;
}

(desde C++23)
De lo contrario, es idéntico a el operador de asignación de movimiento de std::optional .

Miembros idénticos a std:: optional

Funciones miembro

construye el objeto optional
(función miembro pública de std::optional<T> )
destruye el valor contenido, si existe
(función miembro pública de std::optional<T> )
asigna contenido
(función miembro pública de std::optional<T> )
Observadores
accede al valor contenido
(función miembro pública de std::optional<T> )
comprueba si el objeto contiene un valor
(función miembro pública de std::optional<T> )
Modificadores
destruye cualquier valor contenido
(función miembro pública de std::optional<T> )
construye el valor contenido in-situ
(función miembro pública de std::optional<T> )

Notas

Un copyable-box (until C++23) movable-box (since C++23) no contiene un valor solo si

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

Antes de P2325R3 , el contenedor se denominaba semiregular-box en el estándar y siempre satisfacía semiregular , ya que el constructor por defecto siempre se proporcionaba (lo cual podía construir un contenedor sin valor).

Macro de prueba de características Valor Std Característica
__cpp_lib_ranges 201911L (C++20) Biblioteca de rangos y algoritmos restringidos
202106L (C++20)
(DR) 		Vistas no inicializables por defecto
202207L (C++23) Relajación de adaptadores de rango para permitir tipos de solo movimiento

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

DR Aplicado a Comportamiento publicado Comportamiento correcto
P2325R3 C++20 si T no es default_initializable , el constructor por defecto
construye un wrapper que no contiene un valor 		el wrapper 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

(C++20)
una view que contiene un único elemento de un valor especificado
(plantilla de clase) (objeto de punto de personalización)
(C++23)
una view que consiste en una secuencia generada al producir repetidamente el mismo valor
(plantilla de clase) (objeto de punto de personalización)
(C++20)
una view que consiste en los elementos de un range que satisface un predicado
(plantilla de clase) (objeto adaptador de rango)
(C++20)
una view de una secuencia que aplica una función de transformación a cada elemento
(plantilla de clase) (objeto adaptador de rango)
(C++20)
una view que consiste en los elementos iniciales de otra view , hasta el primer elemento en el que un predicado devuelve false
(plantilla de clase) (objeto adaptador de rango)
(C++20)
una view que consiste en los elementos de otra view , omitiendo la subsecuencia inicial de elementos hasta el primer elemento donde el predicado devuelve false
(plantilla de clase) (objeto adaptador de rango)
(C++23)
una view que consiste en los resultados de la aplicación de una función de transformación a elementos correspondientes de las vistas adaptadas
(plantilla de clase) (objeto de punto de personalización)
(C++23)
una view que consiste en los resultados de la aplicación de una función de transformación a elementos adyacentes de la vista adaptada
(plantilla de clase) (objeto adaptador de rango)