C++编译器能否在运算符重载决议过程中执行隐式转换？

你遇到的问题本质是C++重载决议规则的限制：编译器不会通过用户定义的隐式转换，跨类调用另一个类的成员运算符。

为什么原代码中b1 + b2编译失败？ #

当你写b1 + b2时，编译器会优先查找B类的成员operator+，找不到后再找全局operator+，同样找不到。此时编译器不会自动将b1隐式转换为A来调用A的成员operator+——因为C++不允许通过用户定义的隐式转换，间接调用其他类的成员函数。

而static_cast<A>(b1) + b2能编译通过，是因为你显式将b1转换为A，此时调用A的成员operator+时，右操作数b2可以通过隐式转换转为A（函数参数的隐式转换允许单次用户定义转换）。

解决方案 #

方案一：将operator+改为全局非成员函数

全局函数的参数支持隐式转换（包括用户定义转换），两个B对象可以分别转为A后参与运算：

struct A
{
private:
    int _val;
public:
    A(int val) : _val(val) {}
    // 声明为友元以访问私有成员_val
    friend A operator+(const A& lhs, const A& rhs) {
        return A(lhs._val + rhs._val);
    }
};

struct B
{
private:
    int _val;
public:
    B(int val) : _val(val) {}
    // 转换运算符建议加const，符合常量语义
    operator A() const { return A(_val); }
};

int main()
{
    B b1 = {0}, b2 = {1};

    auto a1 = static_cast<A>(b1) + b2; // 正常工作
    auto a2 = b1 + b2;                 // 现在可编译通过，行为与上一行一致
}

方案二：在B类中重载operator+

如果不想修改A类的代码，可以直接在B类中实现加法逻辑，显式转换为A后调用A的运算符：

struct A
{
private:
    int _val;
public:
    A(int val) : _val(val) {}
    // 加const，支持临时A对象调用
    A operator+(const A& a) const {
        return A(_val + a._val);
    }
};

struct B
{
private:
    int _val;
public:
    B(int val) : _val(val) {}
    operator A() const { return A(_val); }

    // 在B中自定义加法逻辑
    A operator+(const B& other) const {
        return static_cast<A>(*this) + static_cast<A>(other);
    }
};

int main()
{
    B b1 = {0}, b2 = {1};

    auto a1 = static_cast<A>(b1) + b2; // 正常工作
    auto a2 = b1 + b2;                 // 现在可编译通过
}

内容的提问来源于stack exchange，提问作者rubikssolver4