英雄类（Hero）

代码实现思路

1. 定义英雄类（Hero）：

   • 包含属性：攻击（atk）、防御（def）、速度（spd）、生命（hp）。
   • 构造函数初始化属性（默认值可设为 0）。
   • 为每个属性提供 set 和 get 方法。
   • equipWeapon方法根据传入的武器类型（通过多态或类型判断）修改英雄属性。
   • show方法输出当前属性。

2. 定义武器类：

   • 短剑（Blade）、长剑（Sword）、斧头（Axe），可通过空类或基类 + 派生类实现（此处因武器无共同行为，直接用空类，通过类型判断处理）。

代码实现

cpp

#include <iostream>
using namespace std;// 武器类（空类，用于类型判断）
class Blade {};  // 短剑
class Sword {};  // 长剑
class Axe {};    // 斧头class Hero {
private:int atk;int def;int spd;int hp;
public:// 构造函数（初始化属性为0）Hero() : atk(0), def(0), spd(0), hp(0) {}// set和get接口void set_atk(int a) { atk = a; }int get_atk() { return atk; }void set_def(int d) { def = d; }int get_def() { return def; }void set_spd(int s) { spd = s; }int get_spd() { return spd; }void set_hp(int h) { hp = h; }int get_hp() { return hp; }// 装备武器方法（通过类型判断处理不同武器）void equipWeapon(const Blade&) {  // 短剑atk += 1;spd += 1;}void equipWeapon(const Sword&) {  // 长剑atk += 1;hp += 1;}void equipWeapon(const Axe&) {    // 斧头atk += 1;def += 1;}// 显示属性void show() {cout << "攻击: " << atk << ", 防御: " << def << ", 速度: " << spd << ", 生命: " << hp << endl;}
};int main() {Hero hero;Blade blade;Sword sword;Axe axe;hero.equipWeapon(blade);  // 装备短剑hero.show();  // 攻击+1，速度+1hero.equipWeapon(sword);  // 装备长剑hero.show();  // 攻击再+1（共2），生命+1hero.equipWeapon(axe);    // 装备斧头hero.show();  // 攻击再+1（共3），防御+1return 0;
}

代码解析

1. 武器类：
   定义三个空类（Blade、Sword、Axe），仅用于类型区分，无需成员（因题目未要求武器有属性或方法，只需类型判断）。

2. 英雄类方法：

   • equipWeapon 重载三个版本，分别处理不同武器类型，根据题目规则修改英雄属性（每种武器都增加 1 点攻击，再额外增加对应属性）。
   • 利用 C++ 的函数重载，根据传入的武器类型自动匹配对应的处理逻辑，实现多态效果（静态多态，通过重载而非虚函数，因武器类无继承关系）。

3. 主函数测试：
   依次装备三种武器，调用show输出属性变化，验证装备效果。

输出结果

plaintext

攻击: 1, 防御: 0, 速度: 1, 生命: 0
攻击: 2, 防御: 0, 速度: 1, 生命: 1
攻击: 3, 防御: 1, 速度: 1, 生命: 1

关键知识点

• 函数重载：通过不同参数类型（武器类）实现同一函数名的不同行为，处理多态逻辑（静态多态）。
• 类的封装：属性私有，通过 public 接口（set、get、装备方法）访问和修改，符合面向对象设计原则。
• 属性修改逻辑：根据题目要求，每种武器对英雄属性的加成不同，通过条件判断（此处通过重载更简洁）实现。

实现思路

1. 定义武器基类（Weapon）：

   • 声明纯虚函数 equip(Hero& hero)，用于装备武器时修改英雄属性。
   • 所有武器类继承自 Weapon，并实现该虚函数。

2. 英雄类（Hero）：

   • 提供统一的 equipWeapon 方法，接收基类指针或引用，通过多态调用具体武器的装备逻辑。

3. 具体武器类：

   • 派生类（Blade、Sword、Axe）重写 equip 方法，实现各自的属性加成规则。

代码实现

cpp

运行

#include <iostream>
using namespace std;class Hero;  // 前向声明，解决循环依赖// 武器基类（抽象类）
class Weapon {
public:virtual void equip(Hero& hero) = 0;  // 纯虚函数，强制子类实现virtual ~Weapon() {}  // 虚析构函数，确保正确释放派生类对象
};// 英雄类
class Hero {
private:int atk;int def;int spd;int hp;
public:Hero() : atk(0), def(0), spd(0), hp(0) {}// 属性访问器void set_atk(int a) { atk = a; }int get_atk() const { return atk; }void set_def(int d) { def = d; }int get_def() const { return def; }void set_spd(int s) { spd = s; }int get_spd() const { return spd; }void set_hp(int h) { hp = h; }int get_hp() const { return hp; }// 装备武器（通过基类指针实现多态）void equipWeapon(Weapon& weapon) {weapon.equip(*this);  // 调用具体武器的装备逻辑}void show() const {cout << "攻击: " << atk << ", 防御: " << def << ", 速度: " << spd << ", 生命: " << hp << endl;}
};// 具体武器类（继承自Weapon）
class Blade : public Weapon {
public:void equip(Hero& hero) override {hero.set_atk(hero.get_atk() + 1);hero.set_spd(hero.get_spd() + 1);}
};class Sword : public Weapon {
public:void equip(Hero& hero) override {hero.set_atk(hero.get_atk() + 1);hero.set_hp(hero.get_hp() + 1);}
};class Axe : public Weapon {
public:void equip(Hero& hero) override {hero.set_atk(hero.get_atk() + 1);hero.set_def(hero.get_def() + 1);}
};int main() {Hero hero;Blade blade;Sword sword;Axe axe;hero.equipWeapon(blade);  // 装备短剑hero.show();  // 输出: 攻击: 1, 防御: 0, 速度: 1, 生命: 0hero.equipWeapon(sword);  // 装备长剑hero.show();  // 输出: 攻击: 2, 防御: 0, 速度: 1, 生命: 1hero.equipWeapon(axe);    // 装备斧头hero.show();  // 输出: 攻击: 3, 防御: 1, 速度: 1, 生命: 1return 0;
}

多态实现的优势

1. 可扩展性：

   • 新增武器类型（如弓箭）时，只需继承 Weapon 类并重写 equip 方法，无需修改 Hero 类代码。

2. 代码复用：

   • 武器的装备逻辑集中在各自的类中，避免 Hero 类中出现大量条件判断。

3. 松耦合：

   • Hero 只依赖武器基类 Weapon，不依赖具体武器类，符合依赖倒置原则。

4. 静态检查：

   • 编译器会检查派生类是否正确实现了虚函数，减少运行时错误。

关键点解析

1. 虚函数与多态：

   • Weapon::equip 是纯虚函数，使 Weapon 成为抽象类，无法实例化。
   • 具体武器类（Blade、Sword、Axe）通过 override 关键字重写 equip 方法，实现多态行为。

2. 基类指针 / 引用：

   • Hero::equipWeapon 接收 Weapon&，可传入任何 Weapon 派生类的对象，运行时根据实际类型调用对应方法。

3. 生命周期管理：

   • 示例中武器对象（blade、sword、axe）在栈上创建，无需手动内存管理。若使用堆内存（如 new Blade()），需确保通过基类指针删除对象（虚析构函数保证正确释放资源）。

输出结果

plaintext

攻击: 1, 防御: 0, 速度: 1, 生命: 0
攻击: 2, 防御: 0, 速度: 1, 生命: 1
攻击: 3, 防御: 1, 速度: 1, 生命: 1

与之前的实现效果一致，但多态方案更符合面向对象设计原则，代码更灵活、可维护。