为什么不为给定的强制转换运算符调用构造函数？

Question

struct A {}; 
struct B
{
  B (A* pA) {}
  B& operator = (A* pA) { return *this; }
};

template<typename T>
struct Wrap
{
  T *x; 
  operator T* () { return x; }
};

int main ()
{
  Wrap<A> a;
  B oB = a; // error: conversion from ‘Wrap<A>’ to non-scalar type ‘B’ requested
  oB = a;  // ok
}

当oB 被构造时，为什么B::B(A*) 没有被Wrap<T>::operator T () 调用？ [注意：B::operator = (A*) 在下一条语句中为Wrap<T>::operator T () 调用]

Answer 1

问题在于隐式调用的用户定义转换的数量受到标准的限制（为 1）。

B ob = a;

意味着两次用户转化：

• a: Wrap<A>::operator A*() 应该被调用
• 关于结果：应该调用B::B(A*)

@James Kanze 的解释：这种语法称为“复制初始化”，实际上等同于B ob = B(a)（大部分时间都省略了复制）。这与 B ob(a) 不同，后者是“直接初始化”并且会起作用。

如果您明确限定其中任何一个，它将起作用，例如：

B ob = B(a);

另一方面，对于第二种情况，没有问题：

ob = a;

是以下的简写：

ob.operator=(a);

因此只需要一次用户定义的转换，这是允许的。

编辑：

由于评论中需要它（对基里尔的回答），我们可以猜测其动机。

链式转换可能很长，很长，因此：

• 可能会让用户感到惊讶——隐式转换可能已经令人惊讶了...
• 可能导致对可能性的指数搜索（对于编译器）——它需要从两端开始，尝试检查所有可能的转换，并以某种方式“加入”两者（尽可能使用最短路径）。

此外，只要有 1 次以上的转换，您就会面临出现周期的风险，这必须被检测到（即使可能不需要诊断，并且受实施质量的约束）。

因此，既然限制是避免无限长搜索所必需的（它可能未指定，但需要一个最小值），并且由于超过 1 我们可能会遇到新问题（循环），因此 1 似乎与限制一样好毕竟任何。

Answer 2

这是因为您使用的是“复制初始化”。如果你写 oB的声明：

B oB(a);

，它应该可以工作。两个初始化的语义是 不同的。对于B oB(a)，编译器尝试查找构造函数 可以使用给定的参数调用。在这种情况下，B::B(A*) 可以调用，因为有来自Wrap<A> 的隐式转换 到A*。对于B oB = a，语义是将a 隐式转换为 输入B，然后使用B的复制构造函数初始化oB。 （这 实际拷贝可以优化出来，但是程序的合法性是 确定好像不是。）并且没有隐式转换 Wrap<A> 到 B，仅限 Wrap<A> 到 A*。

当然，赋值是有效的，因为赋值运算符也 接受A*，因此隐式转换开始发挥作用。

Answer 3

标准不允许链式隐式转换。如果允许，那么您可以编写这样的代码：

struct A
{
   A(int i) //enable implicit conversion from int to A
};  
struct B
{
   B(const A & a); //enable implicit conversion from A to B
};
struct C
{
   C(const B & b); //enable implicit conversion from B to C
}; 
C c = 10; //error

您不能指望10 将转换为A，然后再转换为B，然后再转换为C。

---

B b = 10; //error for same reason!

A a = 10;        //okay, no chained implicit conversion!
B ba = A(10);    //okay, no chained  implicit conversion!
C cb = B(A(10)); //okay, no chained implicit conversion!
C ca = A(10);    //error, requires chained implicit conversion

---

同样的规则适用于隐式调用operator T() 的隐式 转换。

考虑一下，

struct B {};

struct A 
{
   A(int i); //enable implicit conversion from int to A
   operator B(); //enable implicit conversion from B to A
};

struct C
{
   C(const B & b); //enable implicit conversion from B to C
}; 

C c = 10; //error

您不能指望10 将转换为A，然后将转换为B（使用operator B()），然后再转换为C。 S

这种链式隐式转换是不允许的。你必须这样做：

C cb = B(A(10);  //okay. no chained implicit conversion!
C ca = A(10);    //error, requires chained implicit conversion

Answer 4

这是因为 C++ 标准只允许一种用户定义的转换。根据§12.3/4：

最多一个用户定义的转换（构造函数或转换函数）被隐式应用于单个 价值。

B oB = a; // not tried: ob( a.operator T*() ), 1 conversion func+1 constructor
oB = a;   // OK: oB.operator=( a.operator T*() ), 1 conversion func+1 operator=

作为一种解决方法，您可以使用调用构造函数的显式形式：

B oB( a ); // this requires only one implicit user-defined conversion