Question

给出以下结构：

struct ABC
{
    ABC(){cout << "ABC" << endl;}
    ~ABC() noexcept {cout << "~ABC" << endl;}
    ABC(ABC const&) {cout << "copy" << endl;}
    ABC(ABC&&) noexcept {cout << "move" << endl;}
    ABC& operator=(ABC const&){cout << "copy=" << endl;}
    ABC& operator=(ABC&&) noexcept {cout << "move=" << endl;}
};

输出：

std::pair<std::string, ABC> myPair{{}, {}};

是：

ABC
copy
~ABC
~ABC

输出：

std::pair<std::string, ABC> myPair{{}, ABC{}};

是：

ABC
move
~ABC
~ABC

在尝试理解两者之间的差异时，我认为我已经确定第一种情况是使用复制列表初始化，而第二种情况使用未命名临时的直接列表初始化（分别为数字7和2），在这里：http://en.cppreference.com/w/cpp/language/list_initialization）。

正在搜索类似的问题，我发现了这个问题：Why does the standard differentiate between direct-list-initialization and copy-list-initialization?而且：Does copy list initialization invoke copy ctor conceptually?。

这些问题的答案讨论了这样一个事实：对于复制列表初始化，使用显式构造函数会使代码格式错误。事实上，如果我将ABC的默认构造函数显式化，我的第一个例子就不会编译，但这可能是（或许）另一个问题。

所以，问题是：为什么临时复制在第一种情况下，但在第二种情况下移动？是什么阻止在复制列表初始化的情况下移动它？

请注意，以下代码：

std::pair<std::string, ABC> myPair = std::make_pair<string, ABC>({}, {});

还导致调用ABC的移动构造函数（并且没有复制构造函数调用），但可能涉及不同的机制。

您可以在https://ideone.com/Kc8xIn

尝试输出代码（在C ++ 14模式下使用gcc-4.9.2）

Answer 1

通常，像{}这样的 braced-init-lists 不是表达式，也没有类型。如果你有一个功能模板

template<typename T> void f(T);

并致电f( {} )，T不会推断出任何类型，类型扣除也会失败。

另一方面，ABC{}是类型ABC的prvalue表达式（“功能表示法中的显式类型转换”）。对于f( ABC{} )之类的调用，函数模板可以从此表达式中推导出类型ABC。

在C ++ 14和C ++ 11中，std::pair具有以下构造函数[pairs.pair]; T1和T2是std::pair类模板的模板参数的名称：

pair(const pair&) = default;
pair(pair&&) = default;
constexpr pair();
constexpr pair(const T1& x, const T2& y);
template<class U, class V> constexpr pair(U&& x, V&& y);
template<class U, class V> constexpr pair(const pair<U, V>& p);
template<class U, class V> constexpr pair(pair<U, V>&& p);
template <class... Args1, class... Args2>
pair(piecewise_construct_t, tuple<Args1...>, tuple<Args2...>);

请注意，有一个构造函数

constexpr pair(const T1& x, const T2& y); // (C)

但没有

constexpr pair(T1&& x, T2&& y);

相反，有一个完美的转发

template<class U, class V> constexpr pair(U&& x, V&& y); // (P)

如果您尝试使用两个初始化程序初始化std::pair，其中至少有一个是 braced-init-list ，则构造函数（P）不可行，因为它无法推断它的模板参数。

（C）不是构造函数模板。其参数类型T1 const&和T2 const&由类模板参数修复。可以从空 braced-init-list 初始化对常量类型的引用。这将创建一个绑定到引用的临时对象。由于引用的类型是const，（C）构造函数会将其参数复制到类'data members。

中

通过std::pair<T,U>{ T{}, U{} }初始化一对时，T{}和U{}是prvalue表达式。构造函数模板（P）可以推断出它们的类型并且是可行的。类型推导后生成的实例化比（C）构造函数更好地匹配，因为（P）将生成rvalue-reference参数并将prvalue参数绑定到它们。另一方面，（C）将prvalue参数绑定到lvalue-references。

为什么实例会在通过std::pair<T,U>{ {}, U{} }调用时移动第二个参数？

libstdc ++定义了其他构造函数。以下是来自78536ab78e的std::pair实现的摘录，省略了函数定义，一些注释和SFINAE。 _T1和_T2是std::pair类模板的模板参数的名称。

  _GLIBCXX_CONSTEXPR pair();

  _GLIBCXX_CONSTEXPR pair(const _T1& __a, const _T2& __b); // (C)

  template<class _U1, class _U2>
constexpr pair(const pair<_U1, _U2>& __p);

  constexpr pair(const pair&) = default;
  constexpr pair(pair&&) = default;

  // DR 811.
  template<class _U1>
constexpr pair(_U1&& __x, const _T2& __y); // (X)

  template<class _U2>
constexpr pair(const _T1& __x, _U2&& __y); // (E) <=====================

  template<class _U1, class _U2>
constexpr pair(_U1&& __x, _U2&& __y);      // (P)

  template<class _U1, class _U2>
constexpr pair(pair<_U1, _U2>&& __p);

  template<typename... _Args1, typename... _Args2>
    pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>);

注意（E）构造函数模板：它将复制第一个参数并完全转发第二个参数。对于像std::pair<T,U>{ {}, U{} }这样的初始化，它是可行的，因为它只需要从第二个参数中推导出一个类型。对于第二个参数，它也是比（C）更好的匹配，因此总体上更匹配。

“DR 811”注释位于libstdc ++源代码中。它指的是LWG DR 811，它增加了一些SFINAE，但没有新的构造函数。

构造函数（E）和（X）是libstdc ++扩展。不过，我不确定它是否合规。

另一方面，libc ++没有这个额外的构造函数。对于示例std::pair<T,U>{ {}, U{} }，它将copy the second argument。

Live demo with both library implementations

复制列表初始化与临时列表初始化临时

1 个答案: