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*/ ;
(depuis C++20)
(jusqu'à C++23)
( exposition uniquement* )
template < class T >

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

class /*movable-box*/ ;
(depuis C++23)
( exposition uniquement* )

ranges::single_view , ranges::repeat_view , (depuis C++23) et les adaptateurs de gamme qui stockent un objet invocable sont spécifiés en termes d'un modèle de classe d'exposition uniquement copyable-box (jusqu'à C++23) movable-box (depuis C++23) . Le nom affiché ici est uniquement à des fins d'exposition.

Le wrapper se comporte exactement comme std:: optional < T > , sauf que le constructeur par défaut, l'opérateur d'affectation par copie et l'opérateur d'affectation par déplacement sont (conditionnellement) différents de ceux de std::optional , ce qui augmente T avec l'assignabilité lorsque nécessaire et le fait toujours satisfaire copyable ou movable (depuis C++23) .

Si T est déjà copyable , ou si à la fois std:: is_nothrow_move_constructible_v < T > et std:: is_nothrow_copy_constructible_v < T > sont true , /*copyable-box*/ < T > peut stocker uniquement un objet T , car il contient toujours une valeur.

(jusqu'à C++23)

Si T

/*movable-box*/ < T > peut stocker uniquement un objet T , car il contient toujours une valeur.

(depuis C++23)

Table des matières

Paramètres du modèle

T - le type de la valeur contenue, doit être un type objet qui modélise copy_constructible (jusqu'en C++23) move_constructible (depuis C++23)

Fonctions membres

Constructeur par défaut

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

requires std:: default_initializable < T >

: /*copyable-box*/ ( std:: in_place ) { }
(depuis C++20)
(jusqu'à C++23)
constexpr /*movable-box*/ ( ) noexcept ( std:: is_nothrow_default_constructible_v < T > )

requires std:: default_initializable < T >

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

Le constructeur par défaut est fourni si et seulement si T modélise default_initializable .

Un wrapper construit par défaut contient un objet T initialisé par valeur.

Opérateurs d'affectation

(1)
constexpr /*copyable-box*/ & operator = ( const /*copyable-box*/ & other ) ;
noexcept ( /* voir ci-dessous */ ) ;
(depuis C++20)
(jusqu'à C++23)
constexpr /*movable-box*/ & operator = ( const /*movable-box*/ & other ) ;
noexcept ( /* voir ci-dessous */ ) requires std:: copy_constructible < T > ;
(depuis C++23)
(2)
constexpr /*copyable-box*/ & operator = ( /*copyable-box*/ && other )
noexcept ( std:: is_nothrow_move_constructible_v < T > ) ;
(depuis C++20)
(jusqu'à C++23)
constexpr /*movable-box*/ & operator = ( /*movable-box*/ && other )
noexcept ( std:: is_nothrow_move_constructible_v < T > ) ;
(depuis C++23)
1) Si std:: copyable < T > n'est pas satisfait, l'opérateur d'affectation par copie est défini de manière équivalente comme :

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

(jusqu'en 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 ;
}

(depuis C++23)
Sinon, il est identique à l'opérateur d'affectation par copie de std::optional .
2) Si std:: movable < T > n'est pas modélisé, l'opérateur d'affectation par déplacement est défini de manière équivalente comme :

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

(jusqu'en 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 ;
}

(depuis C++23)
Sinon, il est identique à l'opérateur d'affectation par déplacement de std::optional .

Membres identiques à std:: optional

Fonctions membres

construit l'objet optional
(fonction membre publique de std::optional<T> )
détruit la valeur contenue, s'il y en a une
(fonction membre publique de std::optional<T> )
assigne le contenu
(fonction membre publique de std::optional<T> )
Observateurs
accède à la valeur contenue
(fonction membre publique de std::optional<T> )
vérifie si l'objet contient une valeur
(fonction membre publique de std::optional<T> )
Modificateurs
détruit toute valeur contenue
(fonction membre publique de std::optional<T> )
construit la valeur contenue en place
(fonction membre publique de std::optional<T> )

Notes

Un copyable-box (jusqu'à C++23) movable-box (depuis C++23) ne contient une valeur que si

  • T ne modélise pas movable ou copyable , et une exception est levée lors de l'affectation par déplacement ou de l'affectation par copie respectivement, ou
  • il est initialisé/affecté à partir d'un autre wrapper sans valeur.

Avant P2325R3 , le wrapper était appelé semiregular-box dans la norme et satisfaisait toujours semiregular , car le constructeur par défaut était toujours fourni (ce qui pouvait construire un wrapper sans valeur).

Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_ranges 201911L (C++20) Bibliothèque de plages et algorithmes contraints
202106L (C++20)
(DR) 		Vues non initialisables par défaut
202207L (C++23) Assouplissement des adaptateurs de plages pour autoriser les types non copiables

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Appliqué à Comportement publié Comportement corrigé
P2325R3 C++20 si T n'est pas default_initializable , le constructeur par défaut
construit un wrapper qui ne contient pas de valeur 		le wrapper n'est également
pas default_initializable
LWG 3572 C++20 les opérateurs d'affectation conditionnellement différents n'étaient pas constexpr rendus constexpr

Voir aussi

(C++20)
une view qui contient un seul élément d'une valeur spécifiée
(modèle de classe) (objet de point de personnalisation)
(C++23)
une view constituée d'une séquence générée en produisant répétitivement la même valeur
(modèle de classe) (objet de point de personnalisation)
(C++20)
une view qui consiste en les éléments d'un range qui satisfont un prédicat
(modèle de classe) (objet adaptateur de gamme)
(C++20)
une view d'une séquence qui applique une fonction de transformation à chaque élément
(modèle de classe) (objet adaptateur de gamme)
(C++20)
une view constituée des éléments initiaux d'une autre view , jusqu'au premier élément sur lequel un prédicat retourne false
(modèle de classe) (objet adaptateur de gamme)
(C++20)
une view constituée des éléments d'une autre view , en sautant la sous-séquence initiale d'éléments jusqu'au premier élément où le prédicat retourne false
(modèle de classe) (objet adaptateur de gamme)
(C++23)
une view constituée des résultats de l'application d'une fonction de transformation aux éléments correspondants des vues adaptées
(modèle de classe) (objet de point de personnalisation)
(C++23)
une view constituée des résultats de l'application d'une fonction de transformation aux éléments adjacents de la vue adaptée
(modèle de classe) (objet adaptateur de gamme)