C++设计模式_行为型模式_策略模式Strategy

Mr_WangAndy2025-10-22 22:04

策略模式是一种行为型模式，其实现过程与模板方法模式非常类似，都是通过以扩展的方式支持未来的变化。

一个具体实现范例的逐步重构

场景：主角要补充血量，现在要设置三种补血的药丸，分别是补血丹，补充200点生命值，大还丹，补充300生命值，守护丹：补充500点生命值；

创建fighter.h，在其中创建Fighter类---战斗者父类，然后实现战士类和法师类，继承自战斗者父类。

cpp 复制代码 
enum class ItemMedicine
{
	LIFE_BXD, // 补血丹
	LIFE_DHD, // 大还丹
	LIFE_SHD, // 守护丹
};

class Fighter
{
public:
	Fighter(int life, int magic, int attack) :m_life(life), m_magic(magic), m_attack(attack) {}

	// 定义一个吃药的函数
	// 这个函数的参数是一个枚举类型，这个枚举类型定义了各种各样的药品，比如补血丹、大还丹、守护丹等等。
	void useItem(ItemMedicine type)
	{
		if (type == ItemMedicine::LIFE_BXD) //道具类型：补血丹
		{
			m_life += 200;//补充200点生命值
			cout << "补充了补血丹" << endl;
		}
		else if (type == ItemMedicine::LIFE_DHD) //道具类型：大还丹
		{
			m_life += 300;//补充300点生命值
			cout << "补充了大还丹" << endl;
		}
		else if (type == ItemMedicine::LIFE_SHD) //道具类型：守护丹
		{
			m_life += 500;//补充500点生命值
			cout << "补充了守护丹" << endl;
		}
		//.......其他的一些判断逻辑，略。。。。。。
	}
	protected:
		int m_life;
		int m_magic;
		int m_attack;
};

class F_Warrior :public Fighter
{
public:
	F_Warrior(int life, int magic, int attack) :Fighter(life, magic, attack) {}

};;

class F_Mage : public Fighter
{
public:
	F_Mage(int life, int magic, int attack) :Fighter(life, magic, attack) {}

private:

};

上面代码缺点：

如果要增加新的道具，比如 补魔法丹，那么就要在Fighter类中UseItem函数中，增加if else语句，这样就违背了开闭原则---对扩展开放，对修改关闭。

如果怪物也要吃补充生命值的药物，那么就要在Monster类中也增加UseItem函数，这样就违反了单一职责原则，这属于代码级别的重复。

如果主角吃药后，还有其他的一些额外的逻辑，比如吃药后从中毒状态变为正常状态，还要在useItem函数中增加判断语句；同样，如果主角处于狂暴状态，血量要额外增加。这样也 违反的开闭原则。

比如实现吃药后主角从中毒变为正常，需要修改如下：

cpp 复制代码 
	void useItem(ItemMedicine type)
	{
		if (type == ItemMedicine::LIFE_BXD) //道具类型：补血丹
		{
			m_life += 200;//补充200点生命值
			cout << "补充了补血丹" << endl;

			// 
			if （主角中毒）
			{
				// 停止中毒状态，也就是主角吃药后不再中毒
			}
			if （主角处于狂暴状态）
			{
				m_life += 400; //额外再补充400点生命值
				m_magic += 200; //魔法值也再补充200点
			}
		}
		else if (type == ItemMedicine::LIFE_DHD) //道具类型：大还丹
		{
			m_life += 300;//补充300点生命值
			cout << "补充了大还丹" << endl;
		}
		else if (type == ItemMedicine::LIFE_SHD) //道具类型：守护丹
		{
			m_life += 500;//补充500点生命值
			cout << "补充了守护丹" << endl;
		}
		//.......其他的一些判断逻辑，略。。。。。。
	}

使用策略模式对代码重构

策略模式的定义：定义一系列算法（策略类），将每个算法封装起来，让它们可以相互替换。换句话说，策略模式通常把一系列算法（函数）封装到一系列具体策略类中来作为抽象策略类的子类，然后根据实际需要使用这些子类。

策略类中三种角色：

环境类：上面代码中的Fighter类，该类中维持着一个对抽象策略类的指针或引用。

抽象策略类：定义所支持的算法的公共接口，是所有策略类的父类，这里指ItemStrategy

具体策略类：抽象策略类子类，实现抽象策略类中声明的接口，这里指ItemStrategy_BXD ItemStrategy_HHD;

cpp 复制代码 
    class Fighter;

    class ItemStrategy
    {
    public:
        virtual void useItem(Fighter* Fighter) = 0;
        virtual ~ItemStrategy()
        {

        }

    protected:
        Fighter* m_pFighter = nullptr;
    };

    class ItemStrategy_BXD : public ItemStrategy
    {
    public:
        void useItem(Fighter* fighter) override; // 声明，稍后定义
    };

    class ItemStrategy_HHD : public ItemStrategy
    {
    public:
        void useItem(Fighter* fighter) override; // 声明，稍后定义
    };

    class Fighter
    {
    public:
        Fighter() {}
        Fighter(int life, int magic, int attack) :m_life(life), m_magic(magic), m_attack(attack) {}
        virtual  ~Fighter() {}

    public:
        void SetLift(int life)
        {
            m_life = life;
        }

        int  GetLife()
        {
            return m_life;
        }
        void SetItemStrategy(ItemStrategy* itemStrategy)
        {
            m_itemStrategy = itemStrategy;
        }
        void UsetItem()
        {
            m_itemStrategy->useItem(this);
        }

    protected:
        int m_life;
        int m_attack;
        int m_magic;
        ItemStrategy* m_itemStrategy = nullptr;
    };
    // 战士类
    class Warrior : public Fighter
    {
    public:
        using Fighter::Fighter;
    };

    // 将实现放到 Fighter 定义之后
    inline void ItemStrategy_BXD::useItem(Fighter* fighter)
    {
        fighter->SetLift(fighter->GetLife() + 100);
    }

    inline void ItemStrategy_HHD::useItem(Fighter* fighter)
    {
        fighter->SetLift(fighter->GetLife() + 80);
    }

    void test()
    {
        Fighter* fighter = new Warrior(100, 20, 300);

        // 实例化一个对象
        ItemStrategy* ItemStrategy = new ItemStrategy_BXD();
        fighter->SetItemStrategy(ItemStrategy);
        fighter->UsetItem();
    }

策略类优点：

1 以扩展的方式支持对未来的变化，符合开闭原则。遇到大量不稳定的if条件分支 或者switch分支，就要优先考虑是否可以通过策略模式来解决。策略模式是if，switch条件分支的杀手。

2 算法可以被复用。

3 策略模式可以看成是类继承的一种替代方案。通过为环境类对象指定不同的策略，就可以改变环境类对象的行为。比如，战士对象吃大还丹。

策略类的缺点：

1 导致引入许多新策略类；

2 使用策略时，调用者（main主函数）必须熟知所有策略类的功能并根据实际需要自行决定使用哪个策略类。

UML图：

组合关系：Gighter中有straty类的指针。

依赖倒置原则

依赖倒置原则：Dependency Inversion Principle 简称DIP，是面向独享设计的主要实现方法，同时也是实现开闭原则的重要实现途径。

解释：高层组建不应该依赖于底层组建，比如之前的主角（战士，法师）类就是高层组建，怪物类（亡灵类，机械类等）就是底层组建，高层组建不能直接依赖于底层组建，举例：

cpp 复制代码 
namespace _nmsp1
{
	class M_Undead
	{
	public:
		void getinfo()
		{
			cout << "M_Undead" << endl;
		}
	};
	class M_Element
	{
	public:
		void getinfo()
		{
			cout << "M_Element" << endl;
		}
	};
	class M_Mechnical
	{
	public:
		void getinfo()
		{
			cout << "M_Mechnical" << endl;
		}
	};

	// 战士主角
	class Fighter_Warrior
	{
	public:
		// 攻击一种怪物，对应增加一个攻击怪物的函数
		void attack_enemy_undead(M_Undead *p)
		{
			cout << "attack_enemy" << endl;
		}
		void attack_enemy_mechnical(M_Mechnical* p)
		{
			cout << "M_Mechnical" << endl;
		}

	};
}
int main()
{
	// 创建一个高层类
	_nmsp1::Fighter_Warrior *pWar = new _nmsp1::Fighter_Warrior();
	// 创建一个低层类
	_nmsp1::M_Undead* p1 = new _nmsp1::M_Undead();
	// 调用高层类的函数 实现攻击怪物目的
	pWar->attack_enemy_undead(p1);

	// 战士继续攻击另外一种怪物
	_nmsp1::M_Mechnical* p2 = new _nmsp1::M_Mechnical();
	pWar->attack_enemy_mechnical(p2);
	return 0;
}

从上图可以看出，高层组建依赖于底层组建。

改进：

要实现高层组建和底层组建的解耦合，只需要增加一个Monster 类，代码如下：

cpp 复制代码 
namespace _nmsp2
{
	class Monster
	{
	public:
		Monster() {}
		virtual ~Monster()
		{

		}
	};
	class M_Undead : public Monster
	{
	public:
		void getinfo()
		{
			cout << "M_Undead" << endl;
		}
	};
	class M_Element : public Monster
	{
	public:
		void getinfo()
		{
			cout << "M_Element" << endl;
		}
	};
	class M_Mechnical : public Monster
	{
	public:
		void getinfo()
		{
			cout << "M_Mechnical" << endl;
		}
	};

		// 战士主角
	class Fighter_Warrior
	{
	public:
		// 攻击一种怪物，对应增加一个攻击怪物的函数
		void attack_enemy(Monster* p)
		{
			cout << "attack_enemy" << endl;
		}

	};
}

int main()
{
	_nmsp2::Fighter_Warrior *pWar2 = new _nmsp2::Fighter_Warrior();
	// 亡灵类怪物
	_nmsp2::Monster* p1 = new _nmsp2::M_Undead();
	pWar2->attack_enemy(p1);// 攻击亡灵类
	_nmsp2::Monster* p2 = new _nmsp2::M_Mechnical();
	pWar2->attack_enemy(p2);// 攻击亡灵类
	return 0;
}
相关推荐
LoveXming4 小时前
Chapter11—适配器模式
c++·设计模式·适配器模式·开闭原则
Benny_Tang4 小时前
题解：P7989 [USACO21DEC] Bracelet Crossings G
c++·算法
小白杨树树5 小时前
【C++】力扣hot100错误总结
c++·leetcode·c#
ajassi20005 小时前
开源 C++ QT QML 开发（二十三）程序发布
c++·qt·mfc
杯莫停丶5 小时前
设计模式之：单例模式
java·单例模式·设计模式
筱砚.6 小时前
【STL——stack容器】
开发语言·c++
我是华为OD~HR~栗栗呀6 小时前
华为od-22届考研-测试面经
java·c++·python·功能测试·华为od·华为·面试
沐怡旸7 小时前
【穿越Effective C++】条款3：尽可能使用const ——C++不变性的艺术
c++
哼？~7 小时前
C++之智能指针
开发语言·c++
热门推荐
01GitHub 镜像站点02BongoCat - 跨平台键盘猫动画工具03UV安装并设置国内源04Linux下V2Ray安装配置指南05GitLab 零基础入门指南：从安装到项目管理全流程06NVIDIA显卡驱动、CUDA、cuDNN 和 TensorRT 版本匹配指南07一文了解国产算子编程语言 TileLang，TileLang 对国产开源生态的影响与启示082025软件测试面试八股文（含答案+文档）09Labelme从安装到标注：零基础完整指南10在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）