当前位置：首页 > news >正文

C++中避免重复虚函数的三大解决方案：以卡牌游戏开发为例

news 来源：原创 2025/6/21 5:14:45

问题背景

在开发一款卡牌游戏时，通常需要定义一个基类 Card，并通过派生类实现数百种不同的卡牌效果。例如，基类可能如下所示：

class Card {
public:
    virtual ~Card() = default;
    virtual Card* clone() const = 0;  // 克隆函数
    virtual void use() = 0;           // 使用卡牌的效果
};

每个派生类（如 FireballCard、ShieldCard）都需要重写 clone 和 use 方法。若存在几百个派生类，手动编写这些重复的虚函数会极其繁琐。例如：

class FireballCard : public Card {
public:
    Card* clone() const override { return new FireballCard(*this); }
    void use() override { /* 火球效果逻辑 */ }
};

class ShieldCard : public Card {
public:
    Card* clone() const override { return new ShieldCard(*this); }
    void use() override { /* 护盾效果逻辑 */ }
};

这种代码重复不仅效率低下，还难以维护。如何避免这种重复？以下是三种高效的解决方案。

解决方案一：CRTP（奇异递归模板模式）

CRTP（Curiously Recurring Template Pattern） 是一种通过模板继承实现静态多态的技术，可以自动为派生类生成通用方法（如 clone）。

实现步骤

1.定义模板基类：
基类通过模板参数接受派生类类型，并实现通用的 clone 方法。

template <typename Derived>
class CRTPCard : public Card {
public:
    Card* clone() const override {
        return new Derived(static_cast<const Derived&>(*this));
    }
};

2.派生类继承模板基类：
派生类继承 CRTPCard 并传入自身类型，自动获得 clone 方法。

class FireballCard : public CRTPCard<FireballCard> {
public:
    void use() override { /* 火球效果逻辑 */ }
};

class ShieldCard : public CRTPCard<ShieldCard> {
public:
    void use() override { /* 护盾效果逻辑 */ }
};

优势：

零重复代码：所有派生类无需手动实现 clone。
编译期优化：静态多态避免虚函数调用开销。

解决方案二：策略模式（解耦效果逻辑）

若卡牌的效果差异较大（如火球伤害、护盾防御），可以通过策略模式将效果逻辑抽象为独立类，减少派生类数量。

实现步骤

1.定义效果策略接口：

class EffectStrategy {
public:
    virtual ~EffectStrategy() = default;
    virtual void apply() = 0;
    virtual EffectStrategy* clone() const = 0;
};

2.实现具体策略：

class FireEffect : public EffectStrategy {
public:
    void apply() override { /* 火球效果 */ }
    EffectStrategy* clone() const override { return new FireEffect(*this); }
};

class ShieldEffect : public EffectStrategy {
public:
    void apply() override { /* 护盾效果 */ }
    EffectStrategy* clone() const override { return new ShieldEffect(*this); }
};

3.通用卡牌类组合策略：

class UniversalCard : public Card {
    std::unique_ptr<EffectStrategy> effect_;
public:
    explicit UniversalCard(EffectStrategy* effect) : effect_(effect) {}
    Card* clone() const override {
        return new UniversalCard(effect_->clone());
    }
    void use() override { effect_->apply(); }
};

优势：

动态组合效果：通过更换策略实现不同卡牌，无需创建大量派生类。
逻辑解耦：效果实现与卡牌类分离，便于扩展。

解决方案三：数据驱动设计（工业化推荐）

对于复杂卡牌效果（如《杀戮尖塔》），可通过数据驱动设计，用配置文件（如JSON）定义卡牌属性，完全消除派生类。

实现步骤

1.定义JSON配置文件：

// cards.json
{
    "fireball": {
        "cost": 3,
        "effect": {
            "type": "damage",
            "value": 5
        }
    },
    "shield": {
        "cost": 2,
        "effect": {
            "type": "defense",
            "duration": 3
        }
    }
}

2.解析JSON并生成卡牌：
使用 std::variant 和 std::visit 处理多种效果类型。

struct DamageEffect { int value; };
struct DefenseEffect { int duration; };
using Effect = std::variant<DamageEffect, DefenseEffect>;

class DataDrivenCard : public Card {
    Effect effect_;
public:
    DataDrivenCard(const Effect& effect) : effect_(effect) {}
    Card* clone() const override { return new DataDrivenCard(effect_); }
    void use() override {
        std::visit([](auto&& e) {
            // 根据效果类型执行逻辑
            if constexpr (std::is_same_v<decltype(e), DamageEffect>) {
                dealDamage(e.value);
            } else if (std::is_same_v<decltype(e), DefenseEffect>) {
                addDefense(e.duration);
            }
        }, effect_);
    }
};

优势：

零派生类：通过配置而非代码定义卡牌。
灵活迭代：修改配置文件即可调整卡牌效果，无需重新编译。

总结

方案	适用场景	优势
CRTP	需要减少虚函数重复的简单派生类	编译期优化，代码简洁
策略模式	效果差异大的卡牌	逻辑解耦，扩展性强
数据驱动	工业化项目，需动态配置卡牌效果	高度灵活，维护成本低