02.25 继承和多态

编写一个如下场景：
有一个英雄Hero类，私有成员，攻击，防御，速度，生命值，以及所有的set get 方法
编写一个 武器 Weapon 类，拥有私有成员攻击力，以及set get 方法
编写一个 长剑 Sword 类，继承自武器类，拓展属性 生命值，以及set get 方法
编写一个 匕首Blade类，继承自武器类，拓展属性 速度，以及set get 方法
编写一个 斧头 Axe类，继承自武器类，拓展属性 防御力，以及set get 方法

武器Weapon类里面，要求有一个多态函数，叫做 equip 函数
英雄Hero类里面，要求有一个公开函数，equipWeapon(Weapon* w)
实现功能：英雄既可以装备长剑，也可以装备短剑，也可以装备斧头，但是要求装备不同的武器，英雄需要获得不同的属性加成

#include <iostream>
#include <cstring>
#include <cstdlib>
#include <unistd.h>
#include <sstream>
#include <vector>
#include <memory>

using namespace std;

class Hero;

// 武器基类
class Weapon {
private:
    int attack;
public:
    void setAttack(int val) { attack = val; }
    int getAttack() { return attack; }

    // 多态函数，装备武器时的行为
    virtual void equip(Hero* hero) = 0;
};

// 英雄类
class Hero {
private:
    int attack;
    int defense;
    int speed;
    int life;
public:
    void setAttack(int val) { attack = val; }
    void setDefense(int val) { defense = val; }
    void setSpeed(int val) { speed = val; }
    void setLife(int val) { life = val; }

    int getAttack() { return attack; }
    int getDefense() { return defense; }
    int getSpeed() { return speed; }
    int getLife() { return life; }

    // 装备武器函数
    void equipWeapon(Weapon* w) {
        w->equip(this); // 调用武器的equip函数，传入当前英雄对象
    }

    // 打印英雄属性
    void printStats() {
        cout << "英雄属性: " << endl;
        cout << "攻击值: " << attack << endl;
        cout << "防御值: " << defense << endl;
        cout << "速度值: " << speed << endl;
        cout << "生命值: " << life << endl;
    }
};

// 长剑类，继承自武器类
class Sword : public Weapon {
private:
    int lifeBonus; // 生命值加成
public:
    Sword(int attack, int lifeBonus) {
        setAttack(attack);
        this->lifeBonus = lifeBonus;
    }

    void setLifeBonus(int val) { lifeBonus = val; }
    int getLifeBonus() { return lifeBonus; }

    // 实现equip函数，装备长剑时增加英雄的攻击力和生命值
    void equip(Hero* hero) override {
        hero->setAttack(hero->getAttack() + getAttack());
        hero->setLife(hero->getLife() + lifeBonus);
    }
};

// 匕首类，继承自武器类
class Blade : public Weapon {
private:
    int speedBonus; // 速度加成
public:
    Blade(int attack, int speedBonus) {
        setAttack(attack);
        this->speedBonus = speedBonus;
    }

    void setSpeedBonus(int val) { speedBonus = val; }
    int getSpeedBonus() { return speedBonus; }

    // 实现equip函数，装备匕首时增加英雄的攻击力和速度
    void equip(Hero* hero) override {
        hero->setAttack(hero->getAttack() + getAttack());
        hero->setSpeed(hero->getSpeed() + speedBonus);
    }
};

// 斧头类，继承自武器类
class Axe : public Weapon {
private:
    int defenseBonus; // 防御力加成
public:
    Axe(int attack, int defenseBonus) {
        setAttack(attack);
        this->defenseBonus = defenseBonus;
    }

    void setDefenseBonus(int val) { defenseBonus = val; }
    int getDefenseBonus() { return defenseBonus; }

    // 实现equip函数，装备斧头时增加英雄的攻击力和防御力
    void equip(Hero* hero) override {
        hero->setAttack(hero->getAttack() + getAttack());
        hero->setDefense(hero->getDefense() + defenseBonus);
    }
};

int main(int argc, const char** argv) {
    // 创建一个英雄
    Hero hero;
    hero.setAttack(10);
    hero.setDefense(5);
    hero.setSpeed(8);
    hero.setLife(100);

    // 打印初始属性
    cout << "初始化英雄属性:" << endl;
    hero.printStats();

    // 创建不同的武器
    Sword sword(15, 20); // 长剑，攻击力+15，生命值+20
    Blade blade(10, 5);  // 匕首，攻击力+10，速度+5
    Axe axe(20, 10);     // 斧头，攻击力+20，防御力+10

    // 装备长剑
    hero.equipWeapon(&sword);
    cout << endl << "装备长剑后:" << endl;
    hero.printStats();

    // 装备匕首
    hero.equipWeapon(&blade);
    cout << endl << "装备匕首之后:" << endl;
    hero.printStats();

    // 装备斧头
    hero.equipWeapon(&axe);
    cout << endl << "装备斧头之后:" << endl;
    hero.printStats();

    return 0;
}

运行结果：