optional 類別

類別範本 optional<T> 描述的物件，該物件可能或可能不會包含 類型 T的值，稱為 自主值。

當的 optional<T> 實例包含值時，內含的值會配置於 對象的記憶體 optional 內，且區域與類型 T適當對齊。 optional<T>當 轉換成 bool時，結果為 true 如果物件包含值，則為 ，否則為 false。

自主物件類型 T 不得為 in_place_t 或 nullopt_t。 T 必須是 可解構的，也就是說，其解構函式必須回收所有擁有的資源，而且可能不會擲回任何例外狀況。

類別 optional 是 C++17 中的新功能。

語法

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

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

成員

建構函式

名稱	描述
建構函式和解構函式
optional	建構類型 optional 的物件。
~自選	終結 類型的 optional物件。
指派
operator=	將 optional 取代為另一 optional個 的複本。
emplace	使用指定的自變數初始化自主值。
Swap
swap	以另一個 optional交換自主值或空狀態。
觀察員
has_value	傳回物件是否 optional 包含值。
value	傳回自主值。
value_or	傳回自主值，如果沒有值，則傳回替代值。
operator->	參考物件的自主值 optional 。
operator*	參考物件的自主值 optional 。
operator bool	傳回物件是否 optional 包含值。
修飾詞
reset	藉 optional 由終結任何自主值來重設 。

has_value

constexpr bool has_value() const noexcept;

選擇性建構函式

建構類型 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);

參數

rhs
optional要複製或移動的 ，建構所包含的值。

i_list
要從中建構自主值的初始化表達式清單。

args
要從中建構自主值的自變數清單。

備註

constexpr optional() noexcept;constexpr optional(nullopt_t nullopt) noexcept; 這些建構函式會建構 optional 不包含值的 。

constexpr optional(const optional& rhs); 複製建構函式會從 自變數的自主值初始化自主值。 除非 is_copy_constructible_v<T> 為 true，否則會將其定義為已刪除，如果is_trivially_copy_constructible_v<T>為 true，則為微不足道。

constexpr optional(optional&& rhs) noexcept; 移動建構函式會從 自變數的自主值移動，初始化自主值。 除非 is_move_constructible_v<T> 為 true，否則不會參與多載解析，如果 is_trivially_move_constructible_v<T> 為 true，則為微不足道。

template <class... Args> constexpr explicit optional(in_place_t, Args&&... args); 直接初始化自主值，就像使用 自變數 std::forward<Args>(args)一樣。 如果使用的建構函式是 ，則這個 constexpr 建 T 構函式為 constexpr。 除非 為 true，否則 is_constructible_v<T, Args...> 不會參與多載解析。

template <class U, class... Args> constexpr explicit optional(in_place_t, initializer_list<U> i_list, Args&&... args); 直接初始化自主值，就像使用 自變數 i_list, std::forward<Args>(args)一樣。 如果使用的建構函式是 ，則這個 constexpr 建 T 構函式為 constexpr。 除非 為 true，否則 is_constructible_v<T, initializer_list<U>&, Args&&...> 不會參與多載解析。

template <class U = T> explicit constexpr optional(U&& rhs); Direct 會初始化自主值，就像使用 std::forward<U>(v)一樣。 如果使用的建構函式是 ，則這個 constexpr 建 T 構函式為 constexpr。 除非 is_constructible_v<T, U&&> 為 true，且 is_same_v<remove_cvref_t<U>, in_place_t> is_same_v<remove_cvref_t<U>, optional> 為 false，否則不會參與多載解析。

template <class U> explicit optional(const optional<U>& rhs); 如果 rhs 包含值，則直接從自變數的自主值初始化自主值。 除非 is_constructible_v<T, const U&> 為 true，否則不會參與多載解析，且 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_constructible_v<T, optional<U>&&>is_convertible_v<optional<U>&, T>is_convertible_v<const optional<U>&, T> 和 is_convertible_v<const optional<U>&&, T> 全都是 false。

template <class U> explicit optional(optional<U>&& rhs); 如果 rhs 包含值，則直接初始化包含的值，就像使用 std::move(*rhs)一樣。 除非 is_constructible_v<T, U&&> 為 true，否則不會參與多載解析，且 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_constructible_v<T, optional<U>&&>is_convertible_v<optional<U>&, T>is_convertible_v<const optional<U>&, T> 和 is_convertible_v<const optional<U>&&, T> 全都是 false。

~選擇性解構函式

如果存在，則會終結包含的值。

~optional();

備註

如果 T 是可簡單解構的，則 optional<T> 也會是可簡單解構的。

operator=

以複本取代的自主值 optional ，或從另一個 optional 自主值移動。

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&&...);

算子->

取值 物件所包含的值 optional 。

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

operator*

取值 物件所包含的值 optional 。

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

operator bool

報告物件是否 optional 具有自主值。

constexpr explicit operator bool() const noexcept;

reset

實際上，會呼叫自主物件的解構函式，如果有的話，並將它設定為未初始化的狀態。

void reset() noexcept;

swap

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&&) &&;

另請參閱

<optional>