重载强制转换运算符时出现歧义

考虑下面的示例代码：

#include <iostream>

using namespace std;

class dummy
{
   private:
      int y;

   public:
      dummy(int b = 0) : y(b) {
      }

      friend ostream& operator<<(ostream& os, const dummy& obj);
};

ostream& operator<<(ostream& os, const dummy& obj)
{
   os << obj.y;
   return os;
}

class sample
{
   private:
      int x;

   public:
      sample(int a = 0) : x(a)
      {
      }

      operator dummy()
      {
         dummy d(100);
         return d;
      }

      operator int()
      {
         return x;
      }
};

int main()
{
   sample ob1(5);
   dummy d;

   //d = ob1; //Line1  
   d = (dummy)ob1; //Line2

   cout << d << "\n";
}

在 Line1 中，完成了隐式转换。我了解在这种情况下隐式转换是如何工作的。编译器没有给出错误。

但在 Line2 中，显式转换sample对象被完成dummy目的。但编译器给出以下错误。

错误：重载的“dummy(sample&)”调用不明确

注意：候选人是：dummy::dummy(const dummy&)

注意：虚拟::虚拟(int)

问题：

1. 为什么会出现这些错误？

2. 我不明白错误消息的含义。为什么候选函数dummy错误中提到的类？

该行：

d = (dummy)ob1

尝试执行以下操作：

1. 构建一个dummy对象来自obj1
2. 分配那个临时的dummy反对d

第 1 部分是导致问题的原因。为搭建临时dummy编译器必须寻找某种方法来转换对象obj1变成一个类型dummy可以构造自.它发现有两种方法可以做到这一点：

1. Call operator int
2. Call operator dummy

您没有告诉它您希望它采用这两种选择中的哪一种，因此代码是不明确的。

您的问题可以重新创建（删除无关部分），如下所示：

struct t_1 {};
struct t_2 {};
struct sample {
    operator t_1() const{ return t_1(); }
    operator t_2() const{ return t_2(); }
};
void f(t_1) {}
void f(t_2) {}
int main() {
    sample obj1;
    //overload resolution will fail
    //disambiguate with f(obj1.operator t_1()) or f(obj1.operator t_2())
    f(obj1);
}