类模板 optional<T> 描述一个对象，该对象可能或可能不包含称为“包含值”的类型 T 值。
当 optional<T> 的实例包含某值时，所包含的值将分配在针对类型 T 适当对齐的区域中 optional 对象的存储内。 当 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 交换。 |
| Observers | |
| 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) 一样。 如果使用的 T 构造函数是 constexpr，则此构造函数为 constexpr。 除非 is_constructible_v<T, Args...> 为 true，否则它不参与重载解析。
template <class U, class... Args> constexpr explicit optional(in_place_t, initializer_list<U> i_list, Args&&... args); 将直接初始化包含的值，就像使用自变量 i_list, std::forward<Args>(args) 一样。 如果使用的 T 构造函数是 constexpr，则此构造函数为 constexpr。 除非 is_constructible_v<T, initializer_list<U>&, Args&&...> 为 true，否则它不参与重载解析。
template <class U = T> explicit constexpr optional(U&& rhs); 将直接初始化包含的值，就像使用 std::forward<U>(v) 一样。 如果使用的 T 构造函数是 constexpr，则此构造函数为 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_constructible_v<T, optional<U>&&>、is_constructible_v<T, const optional<U>&>、is_constructible_v<T, const optional<U>&&>、is_convertible_v<optional<U>&, T>、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_constructible_v<T, optional<U>&&>、is_constructible_v<T, const optional<U>&>、is_constructible_v<T, const optional<U>&&>、is_convertible_v<optional<U>&, T>、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&&...);
operator->
取消引用 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&&) &&;