Classe facoltativa

Il modello optional<T> di classe descrive un oggetto che può contenere o meno un valore di tipo T, noto come valore contenuto.

Quando un'istanza di optional<T> contiene un valore, il valore contenuto viene allocato all'interno dell'archivio dell'oggetto, in un'area optional allineata in modo adeguato per il tipo T. Quando un oggetto optional<T> viene convertito in bool, il risultato è true se l'oggetto contiene un valore; in caso contrario, è false.

Il tipo di T oggetto contenuto non deve essere in_place_t o nullopt_t. T deve essere distruttore, ovvero il distruttore deve recuperare tutte le risorse di proprietà e non generare eccezioni.

La optional classe è nuova in C++17.

Sintassi

template <class T>
class optional
{
    using value_type = T;
};

template<class T> optional(T) -> optional<T>;

Membri

Costruttori

Nome	Descrizione
Costruttori e distruttori
facoltativo	Costruisce un oggetto di tipo optional.
~opzionale	Elimina definitivamente un oggetto di tipo optional.
Assegnazione
operator=	optional Sostituisce con una copia di un altro optionaloggetto .
emplace	Inizializza il valore contenuto con gli argomenti specificati.
Swap
swap	Scambia il valore contenuto o lo stato vuoto con un altro optionaloggetto .
Osservatori
has_value	Restituisce un valore che indica se un optional oggetto contiene un valore.
value	Restituisce il valore contenuto.
value_or	Restituisce il valore contenuto o un'alternativa se non è presente alcun valore.
operator->	Fa riferimento al valore contenuto di un optional oggetto .
operator*	Fa riferimento al valore contenuto di un optional oggetto .
operator bool	Restituisce un valore che indica se un optional oggetto contiene un valore.
Modificatori
reset	Reimposta l'oggetto optional eliminando qualsiasi valore contenuto.

has_value

constexpr bool has_value() const noexcept;

Costruttore facoltativo

Costruisce un oggetto di tipo optional.

constexpr optional() noexcept;
constexpr optional(nullopt_t nullopt) noexcept;
constexpr optional(const optional& rhs);
constexpr optional(optional&& rhs) noexcept;

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

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

template <class U = T>
explicit constexpr optional(U&& rhs);

template <class U>
explicit optional(const optional<U>& rhs);

template <class U>
explicit optional(optional<U>&& rhs);

Parametri

rhs
Oggetto optional da cui copiare o spostare il valore contenuto.

i_list
Elenco di inizializzatori da cui costruire il valore contenuto.

args
Elenco di argomenti da cui costruire il valore contenuto.

Osservazioni:

constexpr optional() noexcept;constexpr optional(nullopt_t nullopt) noexcept; Questi costruttori costruiscono un oggetto optional che non contiene un valore.

constexpr optional(const optional& rhs); Il costruttore di copia inizializza il valore contenuto dal valore contenuto dell'argomento. Viene definito come eliminato , a meno che is_copy_constructible_v<T> non sia true, ed è semplice se is_trivially_copy_constructible_v<T> è true.

constexpr optional(optional&& rhs) noexcept; Il costruttore di spostamento inizializza il valore contenuto spostando dal valore contenuto dell'argomento. Non partecipa alla risoluzione dell'overload, a meno che is_move_constructible_v<T> non sia vero, ed è semplice se is_trivially_move_constructible_v<T> è vero.

template <class... Args> constexpr explicit optional(in_place_t, Args&&... args); Inizializza direttamente il valore contenuto come se si utilizzassero gli std::forward<Args>(args)argomenti . Questo costruttore è constexpr se il T costruttore usato è constexpr. Non partecipa alla risoluzione dell'overload, a meno che is_constructible_v<T, Args...> non sia true.

template <class U, class... Args> constexpr explicit optional(in_place_t, initializer_list<U> i_list, Args&&... args); Inizializza direttamente il valore contenuto come se si utilizzassero gli i_list, std::forward<Args>(args)argomenti . Questo costruttore è constexpr se il T costruttore usato è constexpr. Non partecipa alla risoluzione dell'overload, a meno che is_constructible_v<T, initializer_list<U>&, Args&&...> non sia true.

template <class U = T> explicit constexpr optional(U&& rhs); Inizializza direttamente il valore contenuto come se si usasse std::forward<U>(v). Questo costruttore è constexpr se il T costruttore usato è constexpr. Non partecipa alla risoluzione dell'overload, a meno che is_constructible_v<T, U&&> non sia true e is_same_v<remove_cvref_t<U>, optional> is_same_v<remove_cvref_t<U>, in_place_t> sia false.

template <class U> explicit optional(const optional<U>& rhs); Se rhs contiene un valore, inizializza direttamente il valore contenuto dal valore contenuto dell'argomento. Non fa parte della risoluzione dell'overload, a meno che is_constructible_v<T, const U&> non sia true e is_constructible_v<T, optional<U>&>, , is_convertible_v<optional<U>&, T>is_constructible_v<T, const optional<U>&&>is_constructible_v<T, const optional<U>&>is_convertible_v<optional<U>&&, T>is_constructible_v<T, optional<U>&&>, is_convertible_v<const optional<U>&, T>e is_convertible_v<const optional<U>&&, T> siano tutti false.

template <class U> explicit optional(optional<U>&& rhs); Se rhs contiene un valore, inizializza direttamente il valore contenuto come se si usasse std::move(*rhs). Non fa parte della risoluzione dell'overload, a meno che is_constructible_v<T, U&&> non sia true e is_constructible_v<T, optional<U>&>, , is_convertible_v<optional<U>&, T>is_constructible_v<T, const optional<U>&&>is_constructible_v<T, const optional<U>&>is_convertible_v<optional<U>&&, T>is_constructible_v<T, optional<U>&&>, is_convertible_v<const optional<U>&, T>e is_convertible_v<const optional<U>&&, T> siano tutti false.

Distruttore ~facoltativo

Elimina definitivamente il valore contenuto, se presente.

~optional();

Osservazioni:

Se T è banalmente distruttore, è optional<T> anche semplice destruibile.

operator=

Sostituisce il valore contenuto di un oggetto optional con una copia o spostarlo da un altro optional valore contenuto.

optional& operator=(nullopt_t) noexcept;
optional& operator=(const optional& rhs);
optional& operator=(optional&&) noexcept( /* see below */ );

template <class U = T>
    optional& operator=(U&&);

template <class U>
optional& operator=(const optional<U>&);

template <class U>
    optional& operator=(optional<U>&&);

template <class... Args>
T& emplace(Args&&...);

template <class U, class... Args>
T& emplace(initializer_list<U>, Args&&...);

operatore->

Dereferenzia il valore contenuto di un optional oggetto .

constexpr const T* operator->() const;
constexpr T* operator->();

operator*

Dereferenzia il valore contenuto di un optional oggetto .

constexpr const T& operator*() const&;
constexpr T& operator*() &;
constexpr T&& operator*() &&;
constexpr const T&& operator*() const&&;

operator bool

Indica se l'oggetto optional ha un valore contenuto.

constexpr explicit operator bool() const noexcept;

reset (ripristina)

In effetti, chiama il distruttore dell'oggetto contenuto, se presente, e lo imposta su uno stato non inizializzato.

void reset() noexcept;

scambio

template<class T>
void swap(optional<T>&, optional<T>&) noexcept;

value

constexpr const T& value() const&;
constexpr T& value() &;
constexpr T&& value() &&;
constexpr const T&& value() const&&;

value_or

template <class U>
    constexpr T value_or(U&&) const&;
template <class U>
    constexpr T value_or(U&&) &&;

Vedi anche

<facoltativo>