函数调用歧义（自定义转换和 Derived2Base 指针转换）

Question

下面代码中函数调用出现歧义的原因是什么？

我知道这里有两个可行的函数，正如编译器在 ERROR 消息中所说的那样（如下所示）

1) candidate: operator==(Base*, Base*)

-> 第一个参数需要用户定义从SmartPtr 到Base* 的转换

-> 需要 Derived* 到 Base* 隐式 (?) 转换

2)candidate: bool operator==(const SmartPtr&, const Base*)

-> 需要为第一个参数添加顶级 const（精确匹配）

-> 需要 Derived* 到 Base* 隐式 (?) 转换

从上面很明显，SmartPtr 内部定义的operator== 是更好的匹配（考虑到第一个参数和第二个参数相同）

代码：

#include <iostream>

using namespace std;

template<class T> class SmartPtr
{
    public:

    operator T*() { return pointee__;}

    inline friend bool operator==(const SmartPtr& lhs, const T* rhs){
        return lhs.pointee__ == rhs;
    }

    private:

    T* pointee__;
};

struct Base{};

class Derived:public Base{};

int main()
{
    SmartPtr<Base> sp;
    Derived * dp;

    cout<<"Hello World"<< (sp==dp);

    return 0;
}

错误：

main.cpp: In function ‘int main()’:
main.cpp:38:30: error: ambiguous overload for ‘operator==’ (operand types are ‘SmartPtr’ and ‘Derived*’)
     cout<<"Hello World"<< (sp==dp);
                            ~~^~~~
main.cpp:38:30: note: candidate: operator==(Base*, Base*) 
main.cpp:19:24: note: candidate: bool operator==(const SmartPtr&, const Base*)
     inline friend bool operator==(const SmartPtr& lhs, const T* rhs){
                        ^~~~~~~~

谢谢！

Answer 1

从上面很明显，在 SmartPtr 中定义的 operator== 是更好的匹配（考虑到第一个参数）

不完全是：第一个转换为SmartPtr & 到SmartPtr const &

第二个需要两次转换：

1) 从Derived * 到Base *

2) 从Base * 到Base const *

如果你定义

Derived * dp;

指向const的指针

Derived const * dp;

歧义消失，代码编译。

如果你定义spconst也是一样

SmartPtr<Base> const sp{};

如果您修改SmartPtr 中的operator==() 以接受Base *（不是Base const *）作为第二个参数，也会消失。