为何operator=无法接受派生类参数？如何实现类似operator+的效果？

为什么a = b没触发自定义的operator=？ #

C++编译器会为类自动生成默认拷贝赋值运算符，对于B类来说，默认生成的版本签名是：

B& operator=(const B& rhs);

当执行a = b时，这个默认版本的参数是const B&，比你自定义的operator=(const A&)匹配优先级更高——因为参数类型完全匹配，不需要隐式转换。编译器会优先选择这个默认版本，而它只会做逐成员拷贝，不会输出任何内容，所以你看不到预期的打印。

为什么a + b能正常调用自定义的operator+？ #

和operator=不同，C++编译器不会自动生成成员版的operator+。当你执行a + b时，没有其他更匹配的运算符可用，此时B对象可以隐式转换为基类A的引用，因此匹配到了你定义的operator+(const A&)，所以能正常输出内容。

要让operator=也能处理B类对象的赋值，有以下几种实用方式：

方法一：显式重载接受const B&的operator= #

直接为B类添加一个匹配B对象的赋值运算符，内部复用已有的基类赋值逻辑：

class B : public A {
public:
    void operator=(const A& rhs) {
        std::cout << "value from operator= " << rhs.value << std::endl;
    }

    // 新增重载版本，专门处理B对象的赋值
    void operator=(const B& rhs) {
        // 调用基类版本的赋值逻辑
        operator=(static_cast<const A&>(rhs));
    }

    void operator+(const A& rhs) {
        std::cout << "value from operator+ " << rhs.value << std::endl;
    }
};

这样a = b会优先匹配这个operator=(const B&)，进而触发你自定义的输出逻辑。

方法二：用模板实现通用赋值（支持所有A的派生类） #

如果需要支持更多从A派生的类，可以用模板定义赋值运算符，同时避免和默认版本冲突：

#include <type_traits> // 需要包含这个头文件

class B : public A {
public:
    template<typename T>
    std::enable_if_t<std::is_base_of_v<A, T>, void>
    operator=(const T& rhs) {
        std::cout << "value from operator= " << rhs.value << std::endl;
    }

    // 禁用默认的拷贝赋值运算符，确保模板版本被选中
    B& operator=(const B&) = delete;

    void operator+(const A& rhs) {
        std::cout << "value from operator+ " << rhs.value << std::endl;
    }
};

这个模板会匹配所有A的派生类型，包括B本身，不过需要显式禁用默认的拷贝赋值运算符，避免优先级冲突。

方法三：虚函数实现多态赋值（适用于基类指针场景） #

如果你的代码存在基类指针指向派生类对象的赋值需求，可以把基类的赋值运算符设为虚函数：

class A {
public:
    int value = 5;
    virtual A& operator=(const A& rhs) {
        value = rhs.value;
        return *this;
    }
};

class B : public A {
public:
    B& operator=(const A& rhs) override {
        if (const B* b_rhs = dynamic_cast<const B*>(&rhs)) {
            // 处理B类型的赋值
            std::cout << "value from operator= " << b_rhs->value << std::endl;
            A::operator=(*b_rhs);
        } else {
            // 处理其他A派生类的赋值
            A::operator=(rhs);
        }
        return *this;
    }

    void operator+(const A& rhs) {
        std::cout << "value from operator+ " << rhs.value << std::endl;
    }
};

这种方式能处理多态场景，但要注意dynamic_cast的性能开销，以及直接用A对象赋值给B对象时的切片问题（会丢失B的特有成员）。

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