std::experimental::optional<T>::optional

constexpr optional() noexcept;
constexpr optional( std::experimental::nullopt_t ) noexcept;
 (1) (库基础 TS)
optional( const optional& other );
 (2) (库基础 TS)
optional( optional&& other ) noexcept(/* see below */);
 (3) (库基础 TS)
constexpr optional( const T& value );
 (4) (库基础 TS)
constexpr optional( T&& value );
 (5) (库基础 TS)
template< class... Args >
constexpr explicit optional( std::experimental::in_place_t, Args&&... args );
 (6) (库基础 TS)
template< class U, class... Args >

constexpr explicit optional( std::experimental::in_place_t,
                             std::initializer_list<U> ilist,

                             Args&&... args );
 (7) (库基础 TS)

构造新 optional 对象。

1) 构造不含值的对象。
2) 复制构造函数：如果 other 含有值，则如同从表达式 *other 直接初始化（但并非直接列表初始化）T 类型的对象一样初始化所含的值。如果 other 并不含有值，则构造不含值的对象。
3) 移动构造函数：如果 other 含有值，则如同从表达式 std::move(*other) 直接初始化（但并非直接列表初始化）T 类型的对象一样初始化所含的值，且并不使 other 为空：被移动 optional 仍然含有值，但其值自身被移动。如果 other 并不含有值，则构造不含值的对象。
4) 构造包含值的 optional 对象，如同从表达式 value 直接初始化（但并非直接列表初始化）T 类型的对象一样进行初始化。如果由直接初始化所选中的 T 的构造函数为 constexpr，则此构造函数为 constexpr。
5) 构造包含值的 optional 对象，如同从表达式 std::move(value) 直接初始化（但并非直接列表初始化）T 类型的对象一样进行初始化。如果由直接初始化所选中的 T 的构造函数为 constexpr，则此构造函数为 constexpr。
6) 构造包含值的 optional 对象，如同从实参 std::forward<Args>(args)... 直接初始化（但并非直接列表初始化）T 类型的对象一样进行初始化。
7) 构造包含值的 optional 对象，如同从实参 ilist, std::forward<Args>(args)... 直接初始化（但并非直接列表初始化）T 类型的对象一样进行初始化。如果 std::is_constructible<T, std::initializer_list<U>&, Args&&...>::value != true，则此函数并不参与重载决议。

Parameters

other - 从中复制其所包含值的另一 optional 对象
value - 用以初始化所包含值的值
args... - 用以初始化所包含值的实参
ilist - 用以初始化所包含值的初始化式列表
类型要求
-
为使用重载 (2,4)， T 必须满足可复制构造 (CopyConstructible) 。
-
为使用重载 (3,5)， T 必须满足可移动构造 (MoveConstructible) 。

异常

2) 抛出 T 的构造函数所抛出的任何异常。
3) 抛出 T 的构造函数所抛出的任何异常。具有如下 noexcept 声明：
noexcept 说明：  
noexcept(std::is_nothrow_move_constructible<T>::value)
4-7) 抛出 T 的构造函数所抛出的任何异常。

示例

#include <experimental/optional>
#include <iostream>
#include <string>
 
int main()
{
    std::experimental::optional<int> o1,      // 空
                                     o2 = 1,  // 从右值初始化
                                     o3 = o2; // 复制构造函数
 
    std::experimental::optional<std::string> o4(std::experimental::in_place,
                                                {'a', 'b', 'c'});
 
    std::cout << *o2 << ' ' << *o3 << ' ' << *o4 << '\n';
}

输出：

1 1 abc

参阅

 创建一个 optional 对象
(函数模板)