关于 std：：variant 中三个构造函数的问题

Questions about three constructors in std::variant's proposed interface

本文关键字：三个 构造函数 问题 std variant 关于      更新时间：2023-10-16

为什么std::variant从http://en.cppreference.com/w/cpp/utility/variant/variant存在构造函数(4)?这似乎会在代码中造成很多歧义，否则可以通过显式来避免这些歧义。例如，cppreference上的代码示例突出了用户可能没有注意到的可能的歧义(第三行)

variant<string> v("abc"); // OK
variant<string, string> w("abc"); // ill-formed, can't select the alternative to convert to
variant<string, bool> w("abc"); // OK, but chooses bool

在某些情况下，它是绝对需要的吗?

另一个问题是为什么构造函数(6)和(8)需要来自同一个cppreference页面。(5)和(7)难道不能达到(6)和(8)的目的吗?我可能误解了它们的用法。

对于读者，我在问题中提到的构造函数是

constexpr variant();              // (1)    (since C++17)
variant(const variant& other);    // (2)    (since C++17)
variant(variant&& other);         // (3)    (since C++17)
template< class T >               // (4)    (since C++17)
constexpr variant(T&& t);
template< class T, class... Args >
constexpr explicit variant(std::in_place_type_t<T>, Args&&... args); // (5) (since C++17)
template< class T, class U, class... Args >
constexpr explicit variant(std::in_place_type_t<T>,
                           std::initializer_list<U> il, Args&&... args); // (6) (since C++17)
template< std::size_t I, class... Args >
constexpr explicit variant(std::in_place_index_t<I>, Args&&... args) // (7) (since C++17)
template <size_t I, class U, class... Args>
constexpr explicit variant(std::in_place_index_t<I>,
                           std::initializer_list<U> il, Args&&... args); // (8) (since C++17)

在某些情况下，它是绝对需要的吗?

。但这些东西不会增加，因为它们"绝对会被需要"。它们被添加是因为它们有用。

从它的一个组件类型隐式转换对于variant是非常有用的。是的，它在某些极端情况下造成了歧义。但是这种歧义通常是由于类型设计的缺陷造成的(比如字符串字面值倾向于转换为bool而不是用户定义的转换)。

如果有一个不明确的情况，那么你必须明确它。比如使用"abc"s UDL字面量而不是裸字符串字面量(这样做的另一个原因)。但是，当你处理设计良好的类型时，没有理由强迫每个都是显式的。

(5)和(7)不能达到(6)和(8)的目的吗?

不合理。

在标准中的每种情况下，当函数接受将传递给构造函数的可变参数时，它们将在该对象上使用构造函数语法而不是{}语法。所以如果你有这个:

using type = vector<int>;
variant<type> t(in_place<type>, 6);

您将接到vector<int>(6)的呼叫。注意，这与vector<int>{6}不同。也就是说，除非你实际传递了一个初始化列表，否则你不会得到初始化列表构造函数。

现在，你可以这样做:

variant<type> t(in_place<type>, initializer_list<int>{6});

但是这太啰嗦了。相比之下:

variant<type> t(in_place<type>, {6});

这样就没那么啰嗦了。编译器可以推断出初始化列表的类型。然而，如果您试图将braced-init-list推断为任意T，则模板参数类型推断会失败。

模板演绎与auto演绎的不同之处在于，它不从braced-init-list表达式中演绎initializer_list s。例如

template <typename Type>
void func(const Type&);
对于下面的调用 ，

不会将Type推断为std::initializer_list

func({1, 2, 3, 4, 5});

要了解更多信息，请参见通用引用和std::initializer_list。

相关文章：