以下代码无法在 gcc 4.8.2 上编译。 问题是此代码将尝试复制构造 std::pair<int, A>由于struct A，这不可能发生缺少复制和移动构造函数。

gcc 在这里失败还是我遗漏了什么？

#include <map>
struct A
{
  int bla;
  A(int blub):bla(blub){}
  A(A&&) = delete;
  A(const A&) = delete;
  A& operator=(A&&) = delete;
  A& operator=(const A&) = delete;
};
int main()
{
  std::map<int, A> map;
  map.emplace(1, 2); // doesn't work
  map.emplace(std::piecewise_construct,
          std::forward_as_tuple(1),
          std::forward_as_tuple(2)
  ); // works like a charm
  return 0;
}

最佳答案

据我所知，问题不是由 map::emplace 引起的。 , 但由 pair的构造函数:

#include <map>

struct A
{
    A(int) {}
    A(A&&) = delete;
    A(A const&) = delete;
};

int main()
{
    std::pair<int, A> x(1, 4); // error
}

据我所知，无论是使用 coliru 的 g++4.8.1 还是 clang++3.5，此代码示例都无法编译，它们都使用 libstdc++。

问题的根源在于，虽然我们可以构造

A t(4);

也就是说，std::is_constructible<A, int>::value == true ，我们不能隐式转换 int到 A [转化]/3

An expression e can be implicitly converted to a type T if and only if the declaration T t=e; is well-formed, for some invented temporary variable t.

注意复制初始化(=)。这会创建一个临时的 A并初始化 t从这个临时的，[dcl.init]/17。这个临时初始化尝试调用 A 的已删除移动 ctor ，这使得转换格式不正确。

因为我们无法从 int 转换到 A ，pair 的构造函数期望被称为被 SFINAE 拒绝。这种行为令人惊讶，N4387 - Improving pair and tuple分析并尝试通过构造构造函数 explicit 来改善这种情况而不是拒绝它。 N4387 在 Lenexa session 上被选为 C++1z。

下面介绍C++11规则。

[pairs.pair]/7-9 中描述了我期望调用的构造函数

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

7    Requires: is_constructible<first_type, U&&>::value is true and is_constructible<second_type, V&&>::value is true.

8    Effects: The constructor initializes first with std::forward<U>(x) and second with std::forward<V>(y).

9    Remarks: If U is not implicitly convertible to first_type or V is not implicitly convertible to second_type this constructor shall not participate in overload resolution.

注意 is_constructible 之间的区别在 Requires 部分中，并且在 Remarks 部分中“不可隐式转换”。满足调用此构造函数的要求，但它可能不参与重载决议(= 必须通过 SFINAE 拒绝)。

因此，重载解析需要选择一个“更差的匹配”，即第二个参数为A const&的匹配。 .临时从 int 创建参数并绑定(bind)到该引用，该引用用于初始化 pair数据成员 (.second)。初始化尝试调用 A 的已删除拷贝 ctor , 并且该对的构造是非良构的。

libstdc++ 有(作为扩展)一些非标准的ctors。在 latest doxygen (以及在 4.8.2 中)，pair 的构造函数我预计会被调用(对标准要求的规则感到惊讶)是:

template<class _U1, class _U2,
         class = typename enable_if<__and_<is_convertible<_U1, _T1>,
                                           is_convertible<_U2, _T2>
                                          >::value
                                   >::type>
constexpr pair(_U1&& __x, _U2&& __y)
: first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }

实际上是调用的是非标准的:

// DR 811.
template<class _U1,
         class = typename enable_if<is_convertible<_U1, _T1>::value>::type>
constexpr pair(_U1&& __x, const _T2& __y)
: first(std::forward<_U1>(__x)), second(__y) { }

根据标准，程序格式不正确，它不仅仅被这个非标准的ctor拒绝。

最后，这里是 is_constructible 的规范。和 is_convertible .

is_constructible [meta.rel]/4

Given the following function prototype:

template <class T>
typename add_rvalue_reference<T>::type create();

the predicate condition for a template specialization is_constructible<T, Args...> shall be satisfied if and only if the following variable definition would be well-formed for some invented variable t:

T t(create<Args>()...);

[Note: These tokens are never interpreted as a function declaration. — end note] Access checking is performed as if in a context unrelated to T and any of the Args. Only the validity of the immediate context of the variable initialization is considered.

is_convertible [meta.unary.prop]/6:

Given the following function prototype:

template <class T>
typename add_rvalue_reference<T>::type create();

the predicate condition for a template specialization is_convertible<From, To> shall be satisfied if and only if the return expression in the following code would be well-formed, including any implicit conversions to the return type of the function:

To test() {
  return create<From>();
}

[Note: This requirement gives well defined results for reference types, void types, array types, and function types. — end note] Access checking is performed as if in a context unrelated to To and From. Only the validity of the immediate context of the expression of the return-statement (including conversions to the return type) is considered.

适合您的类型 A ,

A t(create<int>());

格式正确；然而

A test() {
  return create<int>();
}

创建 A 类型的临时并尝试将其移动到返回值(复制初始化)。选择删除的 ctor A(A&&)因此是不正确的。

关于c++ - 为什么我需要在 map::emplace 中为不可复制对象的单个 arg 构造函数使用分段构造？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/21405674/