c++：设计模式训练

写一个鸟类：有一个多态函数：run
写一个企鹅类，继承自鸟类：重写 run 
写一个鸵鸟类，继承自鸟类，重写 run
写一个老鹰类，继承自鸟类，重写run
写一个鸟笼，能够存放 不同的鸟类对象
      鸟笼是什么类型的自己想
      鸟笼初始化的时候，4个不同的鸟类，至少有一个对象在鸟笼里面
写一个函数，叫做 open_cage
      实现效果：放跑里面的所有鸟类,让所有鸟 run
使用观察者模式实现

from abc import ABC, abstractmethod
from typing import List

# 鸟类接口
class Bird(ABC):
    @abstractmethod
    def run(self) -> str:
        pass

# 具体鸟类实现
class Penguin(Bird):
    def run(self) -> str:
        return "企鹅摇摆着逃走了"

class Ostrich(Bird):
    def run(self) -> str:
        return "鸵鸟大步流星地跑开了"

class Eagle(Bird):
    def run(self) -> str:
        return "老鹰展翅高飞，离开了鸟笼"

# 观察者接口
class Observer(ABC):
    @abstractmethod
    def update(self) -> None:
        pass

# 鸟笼类 - 被观察对象
class BirdCage:
    def __init__(self):
        self._birds: List[Bird] = [
            Penguin(),
            Ostrich(),
            Eagle(),
            Penguin()  # 至少有一个重复的鸟类
        ]
        self._observers: List[Observer] = []

    def add_observer(self, observer: Observer) -> None:
        self._observers.append(observer)

    def remove_observer(self, observer: Observer) -> None:
        self._observers.remove(observer)

    def notify_observers(self) -> None:
        for observer in self._observers:
            observer.update()

    def open(self) -> List[str]:
        """打开鸟笼，放跑所有鸟类"""
        results = [bird.run() for bird in self._birds]
        self._birds.clear()
        self.notify_observers()  # 通知观察者鸟笼已空
        return results

# 实现一个简单的观察者
class CageWatcher(Observer):
    def __init__(self, cage: BirdCage):
        self._cage = cage
        self._cage.add_observer(self)

    def update(self) -> None:
        print("观察者: 鸟笼现在空了!")

# 释放鸟类的函数
def open_cage(cage: BirdCage) -> None:
    """放跑鸟笼中的所有鸟类"""
    results = cage.open()
    for result in results:
        print(result)

# 使用示例
if __name__ == "__main__":
    cage = BirdCage()
    watcher = CageWatcher(cage)
    
    print("打开鸟笼...")
    open_cage(cage)

使用 策略模式 + 简单工厂模式实现以下功能
    有一个英雄类，拥有私有成员: hp ,atk,dep
    英雄可以打怪掉落武器：怪物可以掉落3种武器：
        长剑，匕首，斧头
        英雄装备长剑，获得2点hp
        英雄装备匕首，获得2点atk
        英雄装备斧头，获得2点def
    英雄装备不同的武器，使用策略模式去实现
    注意：测试的时候，英雄在更换武器的时候，记得使用策略模式，将英雄之间装备的武器属性扣除后，再增加新属性
    打败怪物掉落什么武器，自己设计，但是要求怪物掉落武器是一个简单工厂模式

方案一:

#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;

class Weapon;

// 英雄类定义
class Hero {
private:
    int hp = 0;
    int atk = 0;
    int def = 0;
    Weapon* w = NULL;

public:
    void setHp(int h) { hp = h; }
    void setAtk(int a) { atk = a; }
    void setDef(int a) { def = a; }

    int getHp() { return hp; }
    int getAtk() { return atk; }
    int getDef() { return def; }

    void choice_weapon(Weapon* w);
    void equip_weapon();
    void show() {
        cout << "hp = " << hp << endl
             << "atk = " << atk << endl
             << "def = " << def << endl
             << "===========" << endl;
    }
};

// 武器基类定义
class Weapon {
public:
    virtual void equip(Hero& hero) = 0;
    virtual void drop(Hero& hero) = 0;
    virtual ~Weapon() {}
};

// 长剑类，继承自武器基类
class Sword : public Weapon {
public:
    void equip(Hero& hero) override {
        cout << "英雄装备了长剑" << endl;
        int hero_new_hp = hero.getHp() + 2;
        hero.setHp(hero_new_hp);
    }

    void drop(Hero& hero) override {
        int hero_new_hp = hero.getHp() - 2;
        hero.setHp(hero_new_hp);
    }
};

// 短剑类，继承自武器基类
class Blade : public Weapon {
public:
    void equip(Hero& hero) override {
        cout << "英雄装备了短剑" << endl;
        int hero_new_atk = hero.getAtk() + 2;
        hero.setAtk(hero_new_atk);
    }

    void drop(Hero& hero) override {
        int hero_new_atk = hero.getAtk() - 2;
        hero.setAtk(hero_new_atk);
    }
};

// 斧头类，继承自武器基类
class Axe : public Weapon {
public:
    void equip(Hero& hero) override {
        cout << "英雄装备了斧头" << endl;
        int hero_new_def = hero.getDef() + 2;
        hero.setDef(hero_new_def);
    }

    void drop(Hero& hero) override {
        int hero_new_def = hero.getDef() - 2;
        hero.setDef(hero_new_def);
    }
};

// 怪物类，作为武器工厂，生成不同武器
class Monster {
public:
    Weapon* createWeapon() {
        int val = rand() % 3;
        // cout << "val = " << val << endl;
        if (val == 0) {
            return new Sword;
        } else if (val == 1) {
            return new Blade;
        } else if (val == 2) {
            return new Axe;
        }
        return nullptr;
    }
};

// 英雄类中 choice_weapon 方法实现
void Hero::choice_weapon(Weapon* w) {
    if (this->w != NULL) {
        // 选择新武器，记得脱掉上一件武器
        this->w->drop(*this);  // 脱掉上一件武器
        delete this->w;  // 销毁上一件武器
    }
    this->w = w;  // 记录新的武器
}

// 英雄类中 equip_weapon 方法实现
void Hero::equip_weapon() {
    this->w->equip(*this);
}

// 主函数，程序入口
int main(int argc, const char** argv) {
    srand((unsigned int)time(0));  // 更改随机种子，以时间为依据种下随机种子
    Hero hero;
    Monster mon;

    while (1) {
        Weapon* w = mon.createWeapon();
        hero.choice_weapon(w);
        hero.equip_weapon();
        hero.show();
        // step(1);  // 该函数未定义，若需使用需补充实现，这里先注释
    }
    return 0;
}

方案二：

from abc import ABC, abstractmethod
from enum import Enum
import random

# 武器策略接口
class WeaponStrategy(ABC):
    @abstractmethod
    def equip(self, hero) -> None:
        pass

    @abstractmethod
    def unequip(self, hero) -> None:
        pass

# 具体武器策略
class LongswordStrategy(WeaponStrategy):
    def equip(self, hero) -> None:
        hero._hp += 2
        hero._current_weapon = self

    def unequip(self, hero) -> None:
        hero._hp -= 2
        hero._current_weapon = None

class DaggerStrategy(WeaponStrategy):
    def equip(self, hero) -> None:
        hero._atk += 2
        hero._current_weapon = self

    def unequip(self, hero) -> None:
        hero._atk -= 2
        hero._current_weapon = None

class AxeStrategy(WeaponStrategy):
    def equip(self, hero) -> None:
        hero._def += 2
        hero._current_weapon = self

    def unequip(self, hero) -> None:
        hero._def -= 2
        hero._current_weapon = None

# 武器类型枚举
class WeaponType(Enum):
    LONGSWORD = "longsword"
    DAGGER = "dagger"
    AXE = "axe"

# 武器工厂
class WeaponFactory:
    @staticmethod
    def create_weapon(weapon_type: WeaponType) -> WeaponStrategy:
        if weapon_type == WeaponType.LONGSWORD:
            return LongswordStrategy()
        elif weapon_type == WeaponType.DAGGER:
            return DaggerStrategy()
        elif weapon_type == WeaponType.AXE:
            return AxeStrategy()
        else:
            raise ValueError(f"未知武器类型: {weapon_type}")

    @staticmethod
    def from_monster_drop() -> WeaponStrategy:
        """模拟怪物掉落武器"""
        weapon_type = random.choice(list(WeaponType))
        return WeaponFactory.create_weapon(weapon_type)

# 英雄类
class Hero:
    def __init__(self, hp: int, atk: int, defense: int):
        self._hp = hp
        self._atk = atk
        self._def = defense
        self._current_weapon: WeaponStrategy | None = None

    def get_status(self) -> str:
        weapon_name = self._get_weapon_name()
        return f"HP: {self._hp}, ATK: {self._atk}, DEF: {self._def}, 武器: {weapon_name}"

    def _get_weapon_name(self) -> str:
        if self._current_weapon is None:
            return "无"
        elif isinstance(self._current_weapon, LongswordStrategy):
            return "长剑"
        elif isinstance(self._current_weapon, DaggerStrategy):
            return "匕首"
        elif isinstance(self._current_weapon, AxeStrategy):
            return "斧头"
        return "未知武器"

    def equip_weapon(self, weapon: WeaponStrategy) -> None:
        """装备新武器，自动卸下当前武器"""
        if self._current_weapon:
            self._current_weapon.unequip(self)
        weapon.equip(self)
        print(f"装备了{self._get_weapon_name()}")

    def defeat_monster(self) -> WeaponStrategy:
        """击败怪物，获得掉落武器"""
        weapon = WeaponFactory.from_monster_drop()
        print(f"击败怪物，掉落了{self._get_weapon_name_from_type(weapon)}")
        return weapon

    def _get_weapon_name_from_type(self, weapon: WeaponStrategy) -> str:
        if isinstance(weapon, LongswordStrategy):
            return "长剑"
        elif isinstance(weapon, DaggerStrategy):
            return "匕首"
        elif isinstance(weapon, AxeStrategy):
            return "斧头"
        return "未知武器"

# 测试代码
if __name__ == "__main__":
    # 创建英雄
    hero = Hero(hp=10, atk=5, defense=3)
    print("初始状态:", hero.get_status())

    # 击败怪物获得武器并装备
    weapon1 = hero.defeat_monster()
    hero.equip_weapon(weapon1)
    print("当前状态:", hero.get_status())

    # 再次击败怪物获得新武器并装备
    weapon2 = hero.defeat_monster()
    hero.equip_weapon(weapon2)
    print("当前状态:", hero.get_status())

    # 手动更换武器
    weapon3 = WeaponFactory.create_weapon(WeaponType.AXE)
    hero.equip_weapon(weapon3)
    print("当前状态:", hero.get_status())