如何以更优雅的方式为继承体系重载operator+运算符？

你的核心需求是强制派生类实现同类型相加的operator+，同时避免重复的类型转换和冗余代码。原实现的问题在于每个派生类都要手动写dynamic_cast，且只有运行时才能发现类型不匹配的错误。下面给出两种更简洁、更安全的优化方案：

方案一：用CRTP封装通用逻辑 #

通过奇异递归模板模式（CRTP） 将类型转换、多态接口等通用逻辑抽离到基类，让派生类只关注数组相加的核心逻辑：

#include <iostream>
#include <array>
#include <numeric>
#include <memory>
#include <stdexcept>
#include <algorithm>

// CRTP基类：封装类型检查和多态接口
template <typename Derived>
class A
{
public:
    // 纯虚operator+，保持多态能力
    virtual std::shared_ptr<A> operator+(const A& other) const = 0;

protected:
    // 通用类型转换函数，失败抛出异常
    const Derived& cast_to_derived(const A& other) const
    {
        const Derived* derived_ptr = dynamic_cast<const Derived*>(&other);
        if (!derived_ptr)
        {
            throw std::invalid_argument("仅支持同类型对象相加");
        }
        return *derived_ptr;
    }
};

// 派生类B：只需要实现核心相加逻辑
class B : public A<B>
{
public:
    B() { std::iota(data_.begin(), data_.end(), 0); }

    std::array<double, 4> data_;

    // 覆盖基类虚函数，复用基类的类型转换
    std::shared_ptr<A> operator+(const A& other) const override
    {
        const B& other_b = cast_to_derived(other);
        auto result = std::make_shared<B>();
        
        // 用STL算法替代手动循环，更简洁
        std::transform(data_.begin(), data_.end(),
                       other_b.data_.begin(),
                       result->data_.begin(),
                       std::plus<double>());
        return result;
    }

    // 可选：提供类型安全的直接接口，编译期阻止跨类型调用
    std::shared_ptr<B> add(const B& other) const
    {
        return std::static_pointer_cast<B>(operator+(other));
    }
};

int main()
{
    B obj1, obj2;
    
    // 多态接口调用
    std::shared_ptr<A<B>> obj3 = obj1 + obj2;
    // 类型安全接口调用，直接得到B类型指针
    std::shared_ptr<B> obj4 = obj1.add(obj2);

    return 0;
}

优化点说明 #

• 消除重复代码：基类的cast_to_derived函数可以被所有派生类复用，不用每个类都写dynamic_cast
• 编译期类型检查：add接口只接受同类型参数，跨类型调用会直接编译报错，比运行时抛异常更安全
• 简化循环逻辑：用std::transform替代手动for循环，代码更简洁、符合STL风格

方案二：进一步封装operator+，让派生类只实现核心相加 #

如果希望派生类的代码更精简，可以把operator+的实现完全放到基类，派生类只需要实现一个私有的相加方法：

#include <iostream>
#include <array>
#include <numeric>
#include <memory>
#include <stdexcept>
#include <algorithm>

template <typename Derived>
class A
{
public:
    // 基类直接实现operator+，派生类无需再覆盖
    std::shared_ptr<A> operator+(const A& other) const final
    {
        const Derived& derived_other = cast_to_derived(other);
        return static_cast<const Derived*>(this)->add_impl(derived_other);
    }

protected:
    const Derived& cast_to_derived(const A& other) const
    {
        const Derived* derived_ptr = dynamic_cast<const Derived*>(&other);
        if (!derived_ptr)
        {
            throw std::invalid_argument("仅支持同类型对象相加");
        }
        return *derived_ptr;
    }

    // 派生类必须实现的核心相加逻辑
    virtual std::shared_ptr<A> add_impl(const Derived& other) const = 0;
};

class B : public A<B>
{
public:
    B() { std::iota(data_.begin(), data_.end(), 0); }

    std::array<double, 4> data_;

    // 可选的类型安全接口
    std::shared_ptr<B> add(const B& other) const
    {
        return std::static_pointer_cast<B>(operator+(other));
    }

protected:
    // 只需要实现核心相加逻辑
    std::shared_ptr<A> add_impl(const B& other) const override
    {
        auto result = std::make_shared<B>();
        std::transform(data_.begin(), data_.end(),
                       other.data_.begin(),
                       result->data_.begin(),
                       std::plus<double>());
        return result;
    }
};

int main()
{
    B obj1, obj2;
    std::shared_ptr<B> obj3 = obj1.add(obj2);
    return 0;
}

优势 #

• 派生类代码极简：只需要实现add_impl处理数组相加，完全不用管类型转换和多态接口的细节
• 基类统一控制逻辑：所有派生类的operator+行为一致，避免出现不一致的实现

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