面试题：C++抽象类在大型项目架构设计中的深度考量

1. 使用C++抽象类构建游戏角色体系

定义抽象基类
- 创建一个抽象基类 Character，包含所有角色共有的属性和方法的抽象定义。属性可以包括生命值、魔法值、攻击力等，方法可以包括 Attack、Defend 等抽象方法，这些方法将在具体角色类中实现。

class Character {
public:
    virtual void Attack() = 0;
    virtual void Defend() = 0;
    virtual ~Character() = default;
protected:
    int health;
    int mana;
    int attackPower;
};

派生具体角色类
- 从 Character 抽象基类派生出具体的角色类，如 Warrior、Mage、Assassin 等。在这些具体类中实现抽象基类中定义的抽象方法，同时可以添加各自特有的属性和方法。

class Warrior : public Character {
public:
    Warrior() : health(100), mana(20), attackPower(30) {}
    void Attack() override {
        // 实现战士的攻击逻辑
        std::cout << "Warrior attacks with melee weapon." << std::endl;
    }
    void Defend() override {
        // 实现战士的防御逻辑
        std::cout << "Warrior defends with shield." << std::endl;
    }
};

class Mage : public Character {
public:
    Mage() : health(60), mana(80), attackPower(25) {}
    void Attack() override {
        // 实现法师的攻击逻辑
        std::cout << "Mage casts a spell." << std::endl;
    }
    void Defend() override {
        // 实现法师的防御逻辑
        std::cout << "Mage uses a magic shield." << std::endl;
    }
};

class Assassin : public Character {
public:
    Assassin() : health(70), mana(30), attackPower(40) {}
    void Attack() override {
        // 实现刺客的攻击逻辑
        std::cout << "Assassin attacks with a dagger." << std::endl;
    }
    void Defend() override {
        // 实现刺客的防御逻辑
        std::cout << "Assassin dodges." << std::endl;
    }
};

2. 处理角色之间的交互

在抽象基类中定义交互方法
- 在 Character 抽象基类中定义一个 InteractWith 方法，用于处理角色之间的交互。该方法接受另一个 Character 指针作为参数。

class Character {
public:
    virtual void Attack() = 0;
    virtual void Defend() = 0;
    virtual void InteractWith(Character* other) = 0;
    virtual ~Character() = default;
protected:
    int health;
    int mana;
    int attackPower;
};

在具体角色类中实现交互逻辑
- 在每个具体角色类中实现 InteractWith 方法，根据不同角色的特点来定义交互行为。例如，战士可能进行近战攻击，法师可能释放群体法术等。

class Warrior : public Character {
public:
    Warrior() : health(100), mana(20), attackPower(30) {}
    void Attack() override {
        std::cout << "Warrior attacks with melee weapon." << std::endl;
    }
    void Defend() override {
        std::cout << "Warrior defends with shield." << std::endl;
    }
    void InteractWith(Character* other) override {
        std::cout << "Warrior attacks " << typeid(*other).name() << std::endl;
        other->Defend();
    }
};

3. 技能的动态加载与升级

技能抽象类
- 创建一个抽象类 Skill，用于表示所有技能的共性。技能可以有名称、等级、消耗的魔法值等属性，以及一个抽象的 Execute 方法用于执行技能。

class Skill {
public:
    Skill(const std::string& name, int level, int manaCost)
        : name(name), level(level), manaCost(manaCost) {}
    virtual void Execute(Character* caster) = 0;
    virtual ~Skill() = default;
protected:
    std::string name;
    int level;
    int manaCost;
};

具体技能类
- 从 Skill 抽象类派生出具体的技能类，如战士的 Slash 技能、法师的 Fireball 技能等。在这些具体类中实现 Execute 方法。

class Slash : public Skill {
public:
    Slash(int level) : Skill("Slash", level, 10) {}
    void Execute(Character* caster) override {
        std::cout << "Warrior uses Slash. Deals " << level * 5 << " damage." << std::endl;
    }
};

class Fireball : public Skill {
public:
    Fireball(int level) : Skill("Fireball", level, 20) {}
    void Execute(Character* caster) override {
        std::cout << "Mage casts Fireball. Deals " << level * 8 << " damage." << std::endl;
    }
};

技能动态加载与升级
- 在 Character 类中添加一个 std::vector<Skill*> 成员变量来存储角色拥有的技能。通过 LoadSkill 方法动态加载技能，通过 UpgradeSkill 方法升级技能。

class Character {
public:
    virtual void Attack() = 0;
    virtual void Defend() = 0;
    virtual void InteractWith(Character* other) = 0;
    virtual ~Character() {
        for (Skill* skill : skills) {
            delete skill;
        }
    }
    void LoadSkill(Skill* skill) {
        skills.push_back(skill);
    }
    void UpgradeSkill(const std::string& skillName) {
        for (Skill* skill : skills) {
            if (skill->name == skillName) {
                skill->level++;
                std::cout << skillName << " upgraded to level " << skill->level << std::endl;
                break;
            }
        }
    }
protected:
    int health;
    int mana;
    int attackPower;
    std::vector<Skill*> skills;
};

4. 保证系统的可扩展性和可维护性

模块化设计
- 将不同的功能模块分开，如角色模块、技能模块、交互模块等。每个模块有清晰的职责，这样当需要添加新的角色、技能或修改交互逻辑时，只需要在相应的模块中进行修改，不会影响其他模块。
遵循设计模式
- 例如使用工厂模式来创建角色和技能，这样可以将对象的创建和使用分离，便于代码的维护和扩展。例如，可以创建一个 CharacterFactory 类来根据用户的选择创建不同类型的角色。

class CharacterFactory {
public:
    static Character* CreateCharacter(const std::string& type) {
        if (type == "Warrior") {
            return new Warrior();
        } else if (type == "Mage") {
            return new Mage();
        } else if (type == "Assassin") {
            return new Assassin();
        }
        return nullptr;
    }
};

代码注释和文档
- 对关键代码和设计思路进行详细的注释和文档说明，这样新的开发人员可以快速理解代码结构和功能，便于后续的维护和扩展。

星途面试题库

面试题：C++抽象类在大型项目架构设计中的深度考量

知识考点

面试题答案

1. 使用C++抽象类构建游戏角色体系

2. 处理角色之间的交互

3. 技能的动态加载与升级

4. 保证系统的可扩展性和可维护性