这个程序合法吗？

struct X { X(const X &); };
struct Y { operator X() const; };

int main() {
  X{Y{}};   // ?? error
}

在 n2672 之后, 并经 defect 978 修订, 13.3.3.1 [over.best.ics] 具有:

4 - However, when considering the argument of a constructor or user-defined conversion function that is a candidate [...] by 13.3.1.7 [...] when the initializer list has exactly one element and a conversion to some class X or reference to (possibly cv-qualified) X is considered for the first parameter of a constructor of X [...], only standard conversion sequences and ellipsis conversion sequences are considered.

这看起来很反常；它的结果是使用列表初始化强制转换指定转换是非法的:

void f(X);
f(Y{});     // OK
f(X{Y{}});  // ?? error

据我了解n2640 ，列表初始化应该能够取代所有直接初始化和复制初始化的使用，但似乎没有办法从类型 Y 的对象构造类型 X 的对象 仅使用列表初始化:

X x1(Y{});  // OK
X x2 = Y{}; // OK
X x3{Y{}};  // ?? error

这是标准的实际意图吗？如果不是，应该如何阅读或被阅读？

最佳答案

13.3.3.1p4 的初衷是描述如何应用 12.3p4 中的要求:

4 - At most one user-defined conversion (constructor or conversion function) is implicitly applied to a single value.

之前defect 84 , 13.3.3.1p4 几乎纯粹是信息性的:

4 - In the context of an initialization by user-defined conversion (i.e., when considering the argument of a user-defined conversion function; see 13.3.1.4 [over.match.copy], 13.3.1.5 [over.match.conv]), only standard conversion sequences and ellipsis conversion sequences are allowed.

这是因为 13.3.1.4 第 1 段第 2 项和 13.3.1.5p1b1 将候选函数限制为类 S 上的那些函数屈服类型 T , 其中S是初始化表达式的类类型，T是被初始化的对象的类型，所以没有自由插入另一个用户自定义的转换转换序列。 (13.3.1.4p1b1 是另一回事；见下文)。

缺陷 84 修复了 auto_ptr漏洞(即 auto_ptr<Derived> -> auto_ptr<Base> -> auto_ptr_ref<Base> -> auto_ptr<Base> ，通过两个转换函数和一个转换构造函数)通过​​在类复制初始化的第二步中限制构造函数的单个参数允许的转换序列(这里是 auto_ptr<Base> 的构造函数采用 auto_ptr_ref<Base> , 不允许使用转换函数将其参数从 auto_ptr<Base> 转换):

4 - However, when considering the argument of a user-defined conversion function that is a candidate by 13.3.1.3 [over.match.ctor] when invoked for the copying of the temporary in the second step of a class copy-initialization, or by 13.3.1.4 [over.match.copy], 13.3.1.5 [over.match.conv], or 13.3.1.6 [over.match.ref] in all cases, only standard conversion sequences and ellipsis conversion sequences are allowed.

n2672然后添加:

[...] by 13.3.1.7 [over.match.list] when passing the initializer list as a single argument or when the initializer list has exactly one element and a conversion to some class X or reference to (possibly cv-qualified) X is considered for the first parameter of a constructor of X, [...]

这显然令人困惑，因为 13.3.1.3 和 13.3.1.7 唯一候选的转换是构造函数，而不是转换函数。 Defect 978更正此:

4 - However, when considering the argument of a constructor or user-defined conversion function [...]

这也使 13.3.1.4p1b1 与 12.3p4 保持一致，否则将允许在复制初始化中无限制地应用转换构造函数:

struct S { S(int); };
struct T { T(S); };
void f(T);
f(0);   // copy-construct T by (convert int to S); error by 12.3p4

那么问题就是引用 13.3.1.7 的语言是什么意思。 X正在复制或移动构造，因此该语言不包括应用用户定义的转换以达到其 X争论。 std::initializer_list没有转换功能，因此该语言必须适用于其他事物；如果不打算排除转换函数，则必须排除转换构造函数:

struct R {};
struct S { S(R); };
struct T { T(const T &); T(S); };
void f(T);
void g(R r) {
    f({r});
}

列表初始化有两个可用的构造函数； T::T(const T &)和 T::T(S) .通过将复制构造函数排除在考虑之外(因为它的参数需要通过用户定义的转换序列进行转换)，我们确保只有正确的 T::T(S)构造函数被考虑。在没有这种语言的情况下，列表初始化将是不明确的。将初始化列表作为单个参数传递的方式类似:

struct U { U(std::initializer_list<int>); };
struct V { V(const V &); V(U); };
void h(V);
h({{1, 2, 3}});

编辑:经过所有这些，我找到了 a discussion通过 Johannes Schaub这证实了这一分析:

This is intended to factor out the copy constructor for list initialization because since we are allowed to use nested user defined conversions, we could always produce an ambiguous second conversion path by first invoking the copy constructor and then doing the same as we did for the other conversions.

好的，开始提交缺陷报告。我打算建议拆分 13.3.3.1p4:

4 - However, when considering the argument of a constructor or user-defined conversion function that is a candidate:

• by 13.3.1.3 [over.match.ctor] when invoked for the copying of the temporary in the second step of a class copy-initialization, or
• by 13.3.1.4 [over.match.copy], 13.3.1.5 [over.match.conv], or 13.3.1.6 [over.match.ref] in all cases,

only standard conversion sequences and ellipsis conversion sequences are considered; when considering the first argument of a constructor of a class X that is a candidate by 13.3.1.7 [over.match.list] when passing the initializer list as a single argument or when the initializer list has exactly one element, a user-defined conversion to X or reference to (possibly cv-qualified) X is only considered if its user-defined conversion is specified by a conversion function. [Note: because more than one user-defined conversion is allowed in an implicit conversion sequence in the context of list-initialization, this restriction is necessary to ensure that a converting constructor of X, called with a single argument a that is not of type X or a type derived from X, is not ambiguous against a constructor of X called with a temporary X object itself constructed from a. -- end note]

关于c++ - 是否可以通过列表初始化调用用户定义的转换函数？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/12677711/