如何在派生类中实现Compare方法？有无更优替代dynamic_cast的方案？

你的当前实现虽然能工作，但dynamic_cast依赖RTTI且有运行时开销，同时代码可维护性在子类增多后会下降，并非最优解。以下是几种更优的替代方案：

1. 双重分发（Double Dispatch） #

这是处理跨类型多态比较的经典方案，利用虚函数特性在编译期完成类型匹配，完全避免运行时类型检查开销。

修改后的代码示例：

class Item
{
public:
    virtual bool Compare(const Item& InItem) const = 0;
    // 为每个子类定义专属的比较虚函数
    virtual bool CompareWeapon(const Weapon&) const = 0;
    virtual bool CompareArmor(const Armor&) const = 0;
};

class Weapon : public Item
{
public:
    bool Compare(const Item& InItem) const override
    {
        // 调用传入对象的Weapon专属比较函数，完成第二次分发
        return InItem.CompareWeapon(*this);
    }

    bool CompareWeapon(const Weapon& InWeapon) const override
    {
        return Damage == InWeapon.Damage;
    }

    bool CompareArmor(const Armor&) const override
    {
        return false; // 武器与护甲类型不同，直接返回false
    }

private:
    int Damage = 0;
};

class Armor : public Item
{
public:
    bool Compare(const Item& InItem) const override
    {
        return InItem.CompareArmor(*this);
    }

    bool CompareWeapon(const Weapon&) const override
    {
        return false;
    }

    bool CompareArmor(const Armor& InArmor) const override
    {
        return Defence == InArmor.Defence;
    }

private:
    int Defence = 0;
};

优点：无运行时类型检查开销，类型安全，逻辑清晰。
缺点：新增子类时需修改基类，添加对应的CompareXXX虚函数，所有现有子类也要实现该函数，违反开闭原则——适合子类数量固定、不频繁新增的场景。

2. 类型标签（Type Tag） #

在基类中添加枚举类型标识，先通过标签判断类型是否匹配，再用static_cast完成转换（避免dynamic_cast的开销）。

代码示例：

class Item
{
public:
    enum class Type { Weapon, Armor };
    virtual Type GetType() const = 0;
    virtual bool Compare(const Item& InItem) const = 0;
};

class Weapon : public Item
{
public:
    Type GetType() const override { return Type::Weapon; }
    bool Compare(const Item& InItem) const override
    {
        if (InItem.GetType() != Type::Weapon) return false;
        // 类型匹配后用static_cast，安全且无开销
        const Weapon& InWeapon = static_cast<const Weapon&>(InItem);
        return Damage == InWeapon.Damage;
    }

private:
    int Damage = 0;
};

class Armor : public Item
{
public:
    Type GetType() const override { return Type::Armor; }
    bool Compare(const Item& InItem) const override
    {
        if (InItem.GetType() != Type::Armor) return false;
        const Armor& InArmor = static_cast<const Armor&>(InItem);
        return Defence == InArmor.Defence;
    }

private:
    int Defence = 0;
};

优点：开销远低于dynamic_cast，实现简单，新增子类只需扩展枚举并实现GetType。
缺点：需手动维护类型标签，若遗漏类型判断直接static_cast会引发未定义行为。

3. 基于std::variant的无继承方案（C++17+） #

如果可以重构原有继承体系，用std::variant存储不同物品类型，结合std::visit实现类型安全的比较，完全摆脱虚函数和RTTI。

代码示例：

#include <variant>

struct Weapon { int Damage = 0; };
struct Armor { int Defence = 0; };
using Item = std::variant<Weapon, Armor>;

bool Compare(const Item& a, const Item& b)
{
    return std::visit([](const auto& lhs, const auto& rhs) -> bool {
        using LhsType = std::decay_t<decltype(lhs)>;
        using RhsType = std::decay_t<decltype(rhs)>;
        
        // 仅当类型相同时比较属性
        if constexpr (std::is_same_v<LhsType, RhsType>) {
            if constexpr (std::is_same_v<LhsType, Weapon>) {
                return lhs.Damage == rhs.Damage;
            } else if constexpr (std::is_same_v<LhsType, Armor>) {
                return lhs.Defence == rhs.Defence;
            }
        }
        return false;
    }, a, b);
}

优点：无虚函数/RTTI开销，新增类型只需扩展struct和variant，符合开闭原则，代码更简洁。
缺点：依赖C++17及以上标准，原有继承体系需要重构。

当前方案的优缺点 #

• 优点：实现简单，无需修改基类，新增子类只需编写自己的Compare方法。
• 缺点：依赖RTTI，有运行时开销；子类增多后，重复的dynamic_cast代码会降低可维护性；若编译器关闭RTTI，该方案直接失效。

最优解选择 #

• 若子类数量固定、不频繁新增：双重分发是最优选择，兼顾性能与类型安全。
• 若需要频繁新增子类且不想修改基类：类型标签方案比dynamic_cast更高效。
• 若可以重构代码到现代C++：std::variant方案更灵活，长期可维护性更好。

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