struct A { A(int);};
struct B { explicit B(A); B(const B&);};
B b({0}); 

我问了一个问题Overload resolution gets different result between gcc and clang和@Johannes Schaub - litb 解释了活跃的规则。但是我对13.3.3.1.4 Reference binding还有一些疑问。

N4527 13.3.3.1.5 [over.ics.list] p1 和 p8

1 When an argument is an initializer list (8.5.4), it is not an expression and special rules apply for converting it to a parameter type.

8 Otherwise, if the parameter is a reference, see 13.3.3.1.4.

13.3.3.1.4 [over.ics.ref] p1 和 p2

1 When a parameter of reference type binds directly (8.5.3) to an argument expression, the implicit conversion sequence is the identity conversion, unless the argument expression has a type that is a derived class of the parameter type, in which case the implicit conversion sequence is a derived-to-base Conversion (13.3.3.1). [ Example... ]

If the parameter binds directly to the result of applying a conversion function to the argument expression, the implicit conversion sequence is a user-defined conversion sequence (13.3.3.1.2), with the second standard conversion sequence either an identity conversion or, if the conversion function returns an entity of a type that is a derived class of the parameter type, a derived-to-base Conversion.

2 When a parameter of reference type is not bound directly to an argument expression, the conversion sequence is the one required to convert the argument expression to the underlying type of the reference according to 13.3.3.1. Conceptually, this conversion sequence corresponds to copy-initializing a temporary of the underlying type with the argument expression. Any difference in top-level cv-qualification is subsumed by the initialization itself and does not constitute a conversion.

问题一:“参数表达式”是否包括“初始化列表”？请参阅上面的 13.3.3.1.5 [over.ics.list] p1 粗体短语和

1.3.2 [defns.argument]

argument

<function call expression> expression in the comma-separated list bounded by the parentheses (5.2.2)

8.5 [dcl.init] p17

17 The semantics of initializers are as follows. The destination type is the type of the object or reference being initialized and the source type is the type of the initializer expression. If the initializer is not a single (possibly parenthesized) expression, the source type is not defined.

(17.1) — If the initializer is a (non-parenthesized) braced-init-list, the object or reference is list-initialized (8.5.4).

(17.2) — If the destination type is a reference type, see 8.5.3.

8.5.3 [dcl.init.ref] p5

A reference to type “cv1 T1” is initialized by an expression of type “cv2 T2” as follows:

[...]

(5.2.2.2) — Otherwise, a temporary of type “cv1 T1” is created and copy-initialized (8.5) from the initializer expression. The reference is then bound to the temporary.

[...]

除了最后一种情况(即从初始化表达式创建和初始化一个临时对象)之外的所有情况下， 据说引用直接绑定(bind)到初始化表达式。

问题2:“直接绑定(bind)”是否包括初始化器为初始化器列表的情况？换句话说，当初始化器是一个初始化器列表时，我们可以使用“直接绑定(bind)”吗？

注意:“直接绑定(bind)”是 8.5.3 中的定义，由 8.5 p17.1 引用，“初始化程序是花括号初始化列表”是 8.5.4 中的定义，由 8.5 p17.2 引用

//case 5.2.1.2
struct X{};

struct Y{Y(X);};
const Y& y1 = X();     // bind directly
const Y& y2 = {X()};   // bind directly or not?

struct Z{operator X();};
const X& x1 = Z();     // bind directly
const X& x2 = {Z()};   // bind directly or not?

//case 5.2.2.1
struct A{operator int();};
const int& a1 = A();   // bind directly
const int& a2 = {A()}; // bind directly or not?

struct B{B(int);};
const B& b1 = 1;       // bind directly
const B& b2 = {1};     // bind directly or not?

//csse 5.2.2.2
int i3 = 2;
double&& rrd3 = i3;    // not bind directly

struct A { A(int);};
struct B { explicit B(A); B(const B&);};
B b({0}); // when overload resolution choose B(const B&) as a candidate,
          // {0} -> constB& bind directly or not? 

问题 3(主要问题):

当一个参数是一个初始化列表并且参数是一个引用时，13.3.3.1.5 [over.ics.list] p8 引用到 13.3.3.1.4 [over.ics.ref]，但我不能查看有关初始化列表的参数的任何单词。我认为“直接绑定(bind)”和“参数”的定义与“初始化列表”无关。

当参数是初始化列表且参数是引用时，您能解释一下重载决议是如何工作的吗？

注意:这三个问题是相关的。当您回答第三个问题时，您将回答第一个和第二个问题。

struct A { A(int);};
struct B { explicit B(A); B(const B&);};
B b1(0); //when overload resolution choose B(const B&) as a candidate,
         //0 -> const B& binds directly
         //13.3.3.1.4 [over.ics.ref] p1 "If the parameter binds directly..."
A a;
B b2(a)  //when overload resolution choose B(const B&) as a candidate,
         //a -> const B& binds directly
         //13.3.3.1.4 [over.ics.ref] p1 "If the parameter binds directly..."
B b3({0})//when overload resolution choose B(const B&) as a candidate,
         //{0} -> const B& binds directly or not?
         //if it is not bound directly, 13.3.3.1.4 [over.ics.ref] p2
B b3({a})//when overload resolution choose B(const B&) as a candidate,
         //{a} -> const B& binds directly or not?
         //if it is not bound directly, 13.3.3.1.4 [over.ics.ref] p2

最佳答案

我们只是有一个缺陷，报告为 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1536 (我刚刚发现，之前在写其他答案时并没有意识到该报告)。

按照 over.ics.ref 完全不可知的初始化列表的解释，并且正在谈论创建的临时对象(由 decl.init.list 创建的)绑定(bind)到引用，这对我来说似乎有问题。特别地，over.ics.list 表示 over.ics.ref 将委托(delegate)给 over.ics.list 来初始化临时文件，这表明 over.ics.ref 在创建临时文件之前已经处于事件状态(也有一些情况decl.init.list，其中没有创建临时文件)。此外，从 { } 到 ClassType& 应该是用户定义的转换，但在考虑与初始化列表参数隔离的转换时，临时右值将直接由引用绑定(bind)。

关于c++ - 当参数是初始化列表且参数是引用时的重载解析，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/33074102/