重载演员操作时的歧义

Question

请考虑以下示例代码:

#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&)

注意:dummy :: dummy(int)

问题:

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

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

Answer 1

这条线:

d = (dummy)ob1

尝试执行以下操作:

1. 构造一个dummy对象obj1
2. 将该临时dummy对象分配给d

第1部分是导致问题的原因.要构造临时dummy对象,编译器必须搜索某种方式以转换obj1为dummy可以构造的类型.它发现有两种方法可以做到这一点:

1. 呼叫 operator int
2. 呼叫 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);
}