std::optional<T>::optional

来自cppreference.com
 
C++
 
工具库
通用工具
关系运算符 (C++20 弃用)
 
std::optional
 
constexpr optional() noexcept;
constexpr optional( std::nullopt_t ) noexcept;
(1) (C++17 起) 
constexpr optional( const optional& other );
(2) (C++17 起) 
constexpr optional( optional&& other ) noexcept(/* 见下文 */);
(3) (C++17 起) 
template< class U >
optional( const optional<U>& other );
(4) (C++17 起)
(C++20 起为 constexpr)
(条件性 explicit)		 
template< class U >
optional( optional<U>&& other );
(5) (C++17 起)
(C++20 起为 constexpr)
(条件性 explicit)		 
template< class... Args >
constexpr explicit optional( std::in_place_t, Args&&... args );
(6) (C++17 起) 
template< class U, class... Args >
constexpr explicit optional( std::in_place_t,
                             std::initializer_list<U> ilist,
                             Args&&... args );
(7) (C++17 起) 
template< class U = std::remove_cv_t<T> >
constexpr optional( U&& value );
(8) (C++17 起)
(条件性 explicit)

构造新的 optional 对象。

1) 构造一个**不包含**值的对象。
2) 复制构造函数：如果 other 包含一个值，则如同使用表达式 *other 对 T 类型的对象进行直接初始化（而非直接列表初始化）来初始化所含的值。如果 other 不包含值，则构造一个**不包含**值的对象。
  • 如果 std::is_copy_constructible_v<T> 为 false，则该构造函数被定义为弃置的。
  • 如果 std::is_trivially_copy_constructible_v<T> 为 true，则它是一个平凡构造函数。
3) 移动构造函数：如果 other 包含一个值，则如同使用表达式 std::move(*other) 对 T 类型的对象进行直接初始化（而非直接列表初始化）来初始化所含的值，并且**不会**使 other 变为空：被移动后的 std::optional 仍然**包含**一个值，但该值本身已被移走。如果 other 不包含值，则构造一个**不包含**值的对象。
  • 除非 std::is_move_constructible_v<T> 为 true，否则该构造函数不参与重载决议。
  • 如果 std::is_trivially_move_constructible_v<T> 为 true，则它是一个平凡构造函数。
4) 转换复制构造函数：如果 other 不包含值，则构造一个**不包含**值的 optional 对象。否则，构造一个**包含**值的 optional 对象，该值如同使用表达式 *other 对 T 类型的对象进行直接初始化（而非直接列表初始化）来初始化。
  • 除非满足以下条件，否则该构造函数不参与重载决议：
    • std::is_constructible_v<T, const U&> 为 true。
    • 如果 T 不是（可能有 cv 限定的）bool，则 T 不能从任何类型为（可能 const 的）std::optional<U> 的表达式构造或转换，即 converts_from_any_cvref<T, std::optional<U>> 为 false，其中 converts_from_any_cvref 的定义如下所述。
  • 当且仅当 std::is_convertible_v<const U&, T> 为 false 时，此构造函数为 explicit。
5) 转换移动构造函数：如果 other 不包含值，则构造一个**不包含**值的 optional 对象。否则，构造一个**包含**值的 optional 对象，该值如同使用表达式 std::move(*other) 对 T 类型的对象进行直接初始化（而非直接列表初始化）来初始化。
  • 除非满足以下条件，否则该构造函数不参与重载决议：
    • std::is_constructible_v<T, U&&> 为 true。
    • 如果 T 不是（可能有 cv 限定的）bool，则 T 不能从任何类型为（可能有 const 的）std::optional<U> 的表达式构造或转换，即 converts_from_any_cvref<T, std::optional<U>> 为 false，其中 converts_from_any_cvref 的定义如下所述。
  • 当且仅当 std::is_convertible_v<U&&, T> 为 false 时，此构造函数为 explicit。
6) 构造一个**包含**值的 optional 对象，该值如同从实参 std::forward<Args>(args)... 对 T 类型的对象进行直接初始化（而非直接列表初始化）来初始化。
  • 如果 T 所选的构造函数是 constexpr 构造函数，则此构造函数也是 constexpr 构造函数。
  • 除非 std::is_constructible_v<T, Args...> 为 true，否则该函数不参与重载决议。
7) 构造一个**包含**值的 optional 对象，该值如同从实参 ilist, std::forward<Args>(args)... 对 T 类型的对象进行直接初始化（而非直接列表初始化）来初始化。
  • 如果 T 所选的构造函数是 constexpr 构造函数，则此构造函数也是 constexpr 构造函数。
  • 除非 std::is_constructible_v<T, std::initializer_list<U>&, Args...> 为 true，否则该函数不参与重载决议。
8) 构造一个**包含**值的 optional 对象，该值如同使用表达式 std::forward<U>(value) 对 T 类型的对象进行直接初始化（而非直接列表初始化）来初始化。
  • 如果 T 所选的构造函数是 constexpr 构造函数，则此构造函数也是 constexpr 构造函数。
  • 除非满足以下条件，否则该构造函数不参与重载决议：
    • std::is_constructible_v<T, U&&> 为 true。
    • std::decay_t<U>(C++20 前)std::remove_cvref_t<U>(C++20 起) 既不是 std::in_place_t，也不是 std::optional<T>。
    • 如果 T 是（可能有 cv 限定的）bool，则 std::decay_t<U>(C++20 前)std::remove_cvref_t<U>(C++20 起) 不是 std::optional 的特化。
  • 当且仅当 std::is_convertible_v<U&&, T> 为 false 时，此构造函数为 explicit。

辅助变量模板 converts_from_any_cvref 等价于： 

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

参数

other - 要复制其所含值的另一 optional 对象
value - 初始化所含值所用的值
args... - 初始化所含值所用的实参
ilist - 初始化所含值所用的初始化式列表

异常

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

推导指引

注解

在解决 LWG 问题 3836 前，从 std::optional<U> 构造 std::optional<bool> 时，在 U 不是 bool 的情况下会选择重载 (8) 而不是重载 (4,5)。这是因为在 T（这里是 bool）可以从 std::optional<U> 构造或转换时重载决议不会选择重载 (4,5)，但是 std::optional::operator bool 使得该转换适用于所有 U。

这会导致构造的 std::optional<bool> 始终会包含值。该值由提供的 std::optional<U> 对象是否包含值决定，而不是从所含值直接初始化的 bool 值： 

std::optional<bool> op_false(false);
std::optional<int> op_zero(0);
 
std::optional<int> from_bool(op_false); // OK：包含 0（从 false 初始化）
std::optional<bool> from_int(op_zero);  // 缺陷（LWG 3836）：包含 true
                                        // 这是因为 op_zero 包含值，即使
                                        // 从该值初始化 bool 会得出 false
功能特性测试宏 值 标准 功能特性
__cpp_lib_optional 202106L (C++20)
(DR20)		 完全 constexpr (4,5)

示例

运行此代码
#include <iostream>
#include <optional>
#include <string>

int main()
{
    std::optional<int> o1, // 空
                       o2 = 1, // 从右值初始化
                       o3 = o2; // 复制构造函数
    
    // 调用 std::string( initializer_list<CharT> ) 构造函数
    std::optional<std::string> o4(std::in_place, {'a', 'b', 'c'});
    
    // 调用 std::string( size_type count, CharT ch ) 构造函数
    std::optional<std::string> o5(std::in_place, 3, 'A');
    
    // 从 std::string 移动构造，用推导指引拾取类型
    
    std::optional o6(std::string{"deduction"});
    
    std::cout << *o2 << ' ' << *o3 << ' ' << *o4 << ' ' << *o5  << ' ' << *o6 << '\n';
}

输出： 

1 1 abc AAA deduction

缺陷报告

下列更改行为的缺陷报告追溯地应用于以前出版的 C++ 标准。

缺陷报告 应用于 出版时的行为 正确行为
LWG 3836 C++17 从 std::optional<U> 构造 std::optional<bool> 时，
在 U 不是 bool 的情况下会选择重载 (9) 		此时会选择转换复制/移动构造函数
LWG 3886 C++17 重载 (9) 的默认模板实参是 T 改成 std::remove_cv_t<T>
P0602R4 C++17 即使底层构造函数平凡，复制/移动构造函数也不一定平凡 要求传播平凡性
P2231R1 C++20 从另一个 std::optional 进行转换的构造函数 (4,5)
不是 constexpr，但所需操作在 C++20 中本可如此 		使之为 constexpr

参阅

(C++17)
 创建一个 optional 对象
(函数模板) [编辑]