std::optional<T>::optional

constexpr optional() noexcept;
constexpr optional( std::nullopt_t ) noexcept;

constexpr optional( const optional& other );

constexpr optional( optional&& other ) noexcept(/* see below */);

template < class U >
optional( const optional<U>& other );

template < class U >
optional( optional<U>&& other );

template< class... Args >
constexpr explicit optional( std::in_place_t, Args&&... args );

template< class U, class... Args >
constexpr explicit optional( std::in_place_t,
                             std::initializer_list<U> ilist,
                             Args&&... args );

template < class U = std::remove_cv_t<T> >
constexpr optional( U&& value );

Construit un nouvel objet optional.

Le modèle de variable auxiliaire converts_from_any_cvref est équivalent à :

template< class T, class W >
constexpr bool converts_from_any_cvref =
    std::disjunction_v<std::is_constructible<T, W&>, std::is_convertible<W&, T>,
                       std::is_constructible<T, W>, std::is_convertible<W, T>,
                       std::is_constructible<T, const W&>, std::is_convertible<const W&, T>,
                       std::is_constructible<T, const W>, std::is_convertible<const W, T>>;

Paramètres

Exceptions

Notes

Avant la résolution de LWG issue 3836 , la construction d'un std:: optional < bool > à partir d'un std:: optional < U > sélectionnait la surcharge ( 9 ) au lieu des surcharges ( 5,6 ) si U n'est pas bool . Ceci parce que les surcharges ( 5,6 ) ne participaient pas à la résolution de surcharge si T ( bool dans ce cas) peut être construit ou converti à partir de std:: optional < U > , mais std::optional::operator bool rend cette conversion possible pour tout U .

En conséquence, le std:: optional < bool > construit contient toujours une valeur. Cette valeur est déterminée par la présence ou non d'une valeur dans l'objet std:: optional < U > fourni, plutôt que par la valeur bool initialisée directement à partir de la valeur contenue :

std::optional<bool> op_false(false);
std::optional<int> op_zero(0);
std::optional<int> from_bool(op_false); // OK : contient 0 (initialisé à partir de false)
std::optional<bool> from_int(op_zero);  // DÉFAUT (LWG 3836) : contient true car
                                        // op_zero contient une valeur, même si l'initialisation
                                        // de bool à partir de cette valeur donne false

Exemple

#include <iostream>
#include <optional>
#include <string>
int main()
{
    std::optional<int> o1, // vide
                       o2 = 1, // initialisé à partir d'une rvalue
                       o3 = o2; // constructeur par copie
    // appelle le constructeur std::string( initializer_list<CharT> )
    std::optional<std::string> o4(std::in_place, {'a', 'b', 'c'});
    // appelle le constructeur std::string( size_type count, CharT ch )
    std::optional<std::string> o5(std::in_place, 3, 'A');
    // Construit par déplacement depuis std::string en utilisant le guide de déduction pour choisir le type
    std::optional o6(std::string{"deduction"});
    std::cout << *o2 << ' ' << *o3 << ' ' << *o4 << ' ' << *o5  << ' ' << *o6 << '\n';
}

1 1 abc AAA deduction

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.

Voir aussi