C++多态结构中自定义运算符的最优设计：如何避免RTTI实现派生类专属加法逻辑

这个问题简直是多态运算符重载的经典坑——明明知道两个同类型的派生类相加有更高效的实现，但基类引用的静态类型限制让你没法直接触发专属逻辑，用RTTI又总觉得有点“投机取巧”，还容易留下维护隐患。别急，咱们用**双重分派（Double Dispatch）**就能完美解决，完全不用碰RTTI，还符合面向对象的设计原则。

问题核心分析 #

咱们先理清楚为啥直接重载operator+行不通：当你用const A&作为参数时，编译器只能看到静态类型A，没法知道实际传入的是B还是其他派生类。如果硬写RTTI判断，比如dynamic_cast<const B*>(&a1)，不仅代码会变得臃肿，以后加新的派生类时，你得挨个更新判断分支，很容易漏写导致bug。

最优方案：双重分派（Double Dispatch） #

双重分派的核心思路是让两个参与运算的对象都通过虚函数暴露自己的真实类型，从而匹配到对应的专属加法逻辑。具体实现分三步：

1. 改造基类A，添加分派接口 #

首先在基类里定义对外的operator+，以及两个关键的虚函数：一个用于“接受”加法请求，另一个用于处理和特定派生类的加法。

#include <memory>

// 提前声明Sum类
class Sum;

class A {
public:
    virtual ~A() = default;

    // 对外的加法入口，触发双重分派
    std::unique_ptr<A> operator+(const A& other) const {
        return other.accept_add(*this);
    }

    // 虚函数：接受另一个A的加法请求，由派生类实现
    virtual std::unique_ptr<A> accept_add(const A& other) const = 0;

    // 针对不同派生类的加法处理，基类默认返回Sum对象
    virtual std::unique_ptr<A> add_to_A(const A& other) const {
        return std::make_unique<Sum>(other, *this);
    }
    virtual std::unique_ptr<A> add_to_B(const B& other) const {
        return std::make_unique<Sum>(other, *this);
    }
};

2. 派生类B实现专属逻辑 #

在派生类B里，我们需要实现accept_add来引导调用到对应的add_to_B方法，然后重写add_to_B来实现两个B相加的专属逻辑：

class B : public A {
private:
    // 假设B有自己的成员变量
    int value = 0;
public:
    // 实现accept_add：让对方对象调用自己的add_to_B方法
    std::unique_ptr<A> accept_add(const A& other) const override {
        return other.add_to_B(*this);
    }

    // 重写add_to_B，实现两个B的加法，返回B对象而非Sum
    std::unique_ptr<A> add_to_B(const B& other) const override {
        auto result = std::make_unique<B>();
        result->value = this->value + other.value; // 自定义加法逻辑
        return result;
    }
};

3. 调用逻辑 #

现在当你用两个B对象相加时，流程是这样的：

B b1, b2;
b1.value = 5;
b2.value = 3;

auto res = b1 + b2; // res的动态类型是B，而非Sum

具体调用链：b1.operator+(b2) → b2.accept_add(b1) → b1.add_to_B(b2)，完美触发B的专属加法逻辑。如果是B和其他派生类相加，就会走基类的默认逻辑返回Sum。

用CRTP简化重复代码 #

如果你的派生类很多，每个都写accept_add会有大量重复代码，这时候可以用**CRTP（奇异递归模板模式）**来自动生成模板代码：

template<typename Derived>
class A_CRTP : public A {
public:
    std::unique_ptr<A> accept_add(const A& other) const override {
        // 调用对方的对应派生类处理方法
        return other.add_to_derived(static_cast<const Derived&>(*this));
    }
};

// B继承自A_CRTP<B>，无需自己实现accept_add
class B : public A_CRTP<B> {
public:
    std::unique_ptr<A> add_to_B(const B& other) const override {
        auto result = std::make_unique<B>();
        result->value = this->value + other.value;
        return result;
    }
};

这样每个派生类只需要专注实现自己的add_to_xxx方法即可，大大减少了重复代码。

为什么要避免RTTI？ #

很多人反感RTTI不是因为性能（现代编译器的RTTI开销其实很小），而是因为它违背了多态的封装性：

• RTTI让代码依赖于显式的类型判断，而非通过虚函数封装类型逻辑，代码会变得分散且难以维护；
• 新增派生类时，必须记得更新所有RTTI判断的地方，否则会出现“逻辑遗漏”的bug；
• 从设计角度来说，多态的初衷就是让你不用关心具体类型，RTTI相当于把这个封装打破了。

注意事项 #

• 返回值用std::unique_ptr<A>：因为基类A是抽象类，不能返回值类型，用智能指针可以避免内存泄漏；
• 如果需要值语义：可以给基类添加virtual std::unique_ptr<A> clone() const = 0方法，派生类实现clone，加法时返回克隆后的对象；
• 扩展新派生类：比如新增C类，只需要在基类A里添加virtual std::unique_ptr<A> add_to_C(const C& other) const，然后在C类里实现对应方法即可，完全不用修改现有代码，符合开闭原则。

备注：内容来源于stack exchange，提问作者Quasy