std :: optional的转发引用构造函数的约束

Question

std::optional截至此日期有8个构造函数,如下所示(另请参见http://en.cppreference.com/w/cpp/utility/optional/optional)

/* (1) */ constexpr optional() noexcept;
/* (1) */ constexpr optional( std::nullopt_t ) noexcept;

/* (2) */ constexpr optional( const optional& other );

/* (3) */ constexpr optional( optional&& other ) noexcept(/* see below */);

template < class U >
/* (4) */ /* EXPLICIT */ optional( const optional<U>& other );

template < class U >
/* (5) */ /* EXPLICIT */ optional( optional<U>&& other );

template< class... Args > 
/* (6) */ constexpr explicit optional( std::in_place_t, Args&&... args );

template< class U, class... Args >
/* (7) */ constexpr explicit optional( std::in_place_t,
                                       std::initializer_list<U> ilist, 
                                       Args&&... args );

template < class U = value_type >
/* (8) */ /* EXPLICIT */ constexpr optional( U&& value );

我喜欢最后一个构造函数.它有助于std::optional从cv-ref限定的类型引用构造Type.哪个超级方便.

除此之外,最后一个构造函数也有帮助,因为它是一种使用列表初始化来初始化std::optional实例的便捷方式,而不必使用std::in_place.发生这种情况是因为当一个大括号括起来的参数列表被传递给构造函数时,会使用默认类型,因为函数模板不能从中推断出一个类型{}(至少这是我对情况的理解并且是我只选择的一个巧妙的技巧)最近)(另请注意,这只能用于调用基础类型的非显式构造函数,根据此处的规则http://en.cppreference.com/w/cpp/language/list_initialization)

auto optional = std::optional<std::vector<int>>{{1, 2, 3, 4}};

我能理解的最后一个构造函数有两个约束

• std::decay_t<U>既不是也不std::in_place_t是std::optional<T>
• 当且仅当std::is_convertible_v<U&&, T>false为false时,此构造函数是显式的

第一个是易于理解的,它有助于防止与构造函数(2),(3),(4),(5),(6)和(7)的歧义.如果类型是std::in_place 它可能与(6)和(7)冲突.如果类型是实例,std::optional那么它可能与(2),(3),(4)和(5)冲突.

第二个只是"转发"基础类型的构造函数对类型的显optional式性

但第三个限制是好奇的

• 除非std::is_constructible_v<T, U&&>是真的,否则此构造函数不参与重载决策

为什么需要这个？(8)永远不会与空构造函数冲突,因为它至少需要一个参数.这只剩下一个原因 - 它可能与std::nullopt_t传递时相冲突std::nullopt,但这不会发生,因为nullopt无论cv-ref合格版本std::nullopt_t是什么,版本总是更好的匹配(如下所示)

void func(int) {
    cout << __PRETTY_FUNCTION__ << endl;
}

template <typename U>
void func(U&&) {
    cout << __PRETTY_FUNCTION__ << endl;
}

int main() {
    auto i = int{1};
    func(1);
    func(i);
    func(std::move(i));
    func(std::as_const(i));
    func(std::move(std::as_const(i)));
}

最后一次限制背后的原因是什么？

为什么不像往常一样让构造函数出错呢？这是否需要帮助检测类型是否可通过SFINAE传递的参数构造,而不会在以后导致硬错误？

Answer 1

说谎的特质是不好的.

基本词汇类型的谎言特征是plusungood.

对于基本词汇类型而言也很容易干扰重载分辨率的特征是doubleplusungood.

void f(std::optional<int>);
void f(std::optional<const char*>);
f({""}); // ambiguous without the constraint