鉴于以下情况:

#include <stdio.h>

class X;

class Y
{
public:
  Y() { printf("  1\n"); }             // 1
  // operator X(); // 2
};

class X
{
public:
  X(int) {}
  X(const Y& rhs) { printf("  3\n"); } // 3
  X(Y&& rhs) { printf("  4\n"); }      // 4
};

// Y::operator X() { printf("   operator X() - 2\n"); return X{2}; }

int main()
{
  Y y{};     // Calls (1)

  printf("j\n");
  X j{y};    // Calls (3)
  printf("k\n");
  X k = {y}; // Calls (3)
  printf("m\n");
  X m = y;   // Calls (3)
  printf("n\n");
  X n(y);    // Calls (3)

  return 0;
}

到目前为止，一切都很好。现在，如果我启用转换运算符 Y::operator X()，我会得到这个；-

  X m = y; // Calls (2)

我的理解是，发生这种情况是因为 (2) 比 (3) '更少 const' 并且 因此首选。省略了对 X 构造函数的调用

我的问题是，为什么定义 X k = {y} 没有以同样的方式改变它的行为？我知道 = {} 在技术上是“列表复制初始化”，但是在没有采用 initializer_list 类型的构造函数的情况下，这不会恢复为“复制初始化”行为？即 - 与 X m = y

我的理解的漏洞在哪里？

最佳答案

Where is the hole in my understanding?

tltldr;没人懂初始化。

tldr;列表初始化首选 std::initializer_list<T>构造函数，但它不会回退到非列表初始化。它只回退到考虑构造函数。非列表初始化会考虑转换函数，但回退不会。

所有的初始化规则都来自[dcl.init] .所以让我们从第一原则开始吧。

[dcl.init]/17.1 :

• If the initializer is a (non-parenthesized) braced-init-list or is = braced-init-list, the object or reference is list-initialized.

第一个要点涵盖所有列表初始化。这个跳转X x{y}和 X x = {y}转至 [dcl.init.list] .我们会回到那个。另一种情况更容易。来看看X x = y .我们直接调用:

[dcl.init]/17.6.3 :

• Otherwise (i.e., for the remaining copy-initialization cases), user-defined conversion sequences that can convert from the source type to the destination type or (when a conversion function is used) to a derived class thereof are enumerated as described in [over.match.copy], and the best one is chosen through overload resolution.

[over.match.copy] 中的候选人是:

• The converting constructors of T [in our case, X] are candidate functions.
• When the type of the initializer expression is a class type “cv S”, the non-explicit conversion functions of S and its base classes are considered.

In both cases, the argument list has one argument, which is the initializer expression.

这给了我们候选人:

X(Y const &);     // from the 1st bullet
Y::operator X();  // from the 2nd bullet

第二个等价于有一个X(Y& ) ，因为转换函数不是 cv 限定的。这使得 cv 限定的引用比转换构造函数少，所以它是首选。注意，没有调用 X(X&& )在 C++17 中。

现在让我们回到列表初始化案例。第一个相关的要点是 [dcl.init.list]/3.6 :

Otherwise, if T is a class type, constructors are considered. The applicable constructors are enumerated and the best one is chosen through overload resolution ([over.match], [over.match.list]). If a narrowing conversion (see below) is required to convert any of the arguments, the program is ill-formed.

在这两种情况下都将我们带到 [over.match.list]它定义了两阶段过载解决方案:

• Initially, the candidate functions are the initializer-list constructors ([dcl.init.list]) of the class T and the argument list consists of the initializer list as a single argument.
• If no viable initializer-list constructor is found, overload resolution is performed again, where the candidate functions are all the constructors of the class T and the argument list consists of the elements of the initializer list.

If the initializer list has no elements and T has a default constructor, the first phase is omitted. In copy-list-initialization, if an explicit constructor is chosen, the initialization is ill-formed.

候选者是 X 的构造函数. X x{y} 之间的唯一区别和 X x = {y}如果后者选择 explicit构造函数，初始化格式不正确。我们甚至没有任何explicit构造函数，所以两者是等价的。因此，我们枚举我们的构造函数:

• X(Y const& )
• X(X&& )通过Y::operator X()

前者是直接引用绑定(bind)，是精确匹配。后者需要用户定义的转换。因此，我们更喜欢 X(Y const& )在这种情况下。

请注意，gcc 7.1 在 C++1z 模式下会出错，所以我提交了 bug 80943 .

关于c++ - 复制初始化表单 '= {}'，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/44306607/