C++ 设计模式——策略模式

embedded/2024/10/15 19:12:11/

策略模式

    • 策略模式
      • 主要组成部分
      • 例一：逐步重构并引入策略模式
        • 第一步：初始实现
        • 第二步：提取共性并实现策略接口
        • 第三步：实现具体策略类
        • 第四步：实现上下文类
        • 策略模式 UML 图
      • 例二：逐步重构并引入策略模式
        • 第一步：初始实现
        • 第二步：提取共性并实现策略接口
        • 第三步：实现具体策略类
        • 第四步：实现上下文类：
        • 第五步：更新主函数
      • 策略模式 UML 图
      • 策略模式优缺点
      • 策略模式适用场景
      • 例一的完整代码
      • 例二的完整代码

策略模式

策略模式是一种行为设计模式，它定义了一系列算法，将每一个算法封装起来，并使它们可以互换。策略模式让算法的变化独立于使用算法的客户。

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

主要组成部分

  • 策略接口 (Strategy)：定义一个统一的接口，声明所有支持的算法（策略）的方法。客户端通过这个接口调用具体策略。

  • 具体策略类 (Concrete Strategy)：实现策略接口，定义具体的算法或行为。每个具体策略类实现不同的算法。

  • 上下文类 (Context)：持有对策略接口的引用，负责调用具体策略的方法。上下文类可以在运行时动态地切换策略。

例一：逐步重构并引入策略模式

假设我们需要实现不同的排序算法（如冒泡排序和快速排序）。最初的实现可能是重复的代码。逐步重构的过程如下：

第一步：初始实现

为每种排序算法编写独立的处理逻辑：

#include <iostream>
#include <vector>void bubbleSort(std::vector<int>& arr) {for (size_t i = 0; i < arr.size() - 1; ++i) {for (size_t j = 0; j < arr.size() - i - 1; ++j) {if (arr[j] > arr[j + 1]) {std::swap(arr[j], arr[j + 1]);}}}
}void quickSort(std::vector<int>& arr, int low, int high) {if (low < high) {int pivot = arr[high];int i = low - 1;for (int j = low; j < high; ++j) {if (arr[j] < pivot) {++i;std::swap(arr[i], arr[j]);}}std::swap(arr[i + 1], arr[high]);quickSort(arr, low, i);quickSort(arr, i + 2, high);}
}int main() {std::vector<int> data = {5, 3, 8, 6, 2};bubbleSort(data);// 或者使用 quickSort(data, 0, data.size() - 1);return 0;
}
第二步：提取共性并实现策略接口

识别出排序的共性步骤，并创建一个策略接口 SortStrategy，定义排序方法：

class SortStrategy {
public:virtual void sort(std::vector<int>& arr) = 0; // 策略接口
};
第三步：实现具体策略类

为每种排序算法实现具体策略类，重写排序方法：

class BubbleSort : public SortStrategy {
public:void sort(std::vector<int>& arr) override {for (size_t i = 0; i < arr.size() - 1; ++i) {for (size_t j = 0; j < arr.size() - i - 1; ++j) {if (arr[j] > arr[j + 1]) {std::swap(arr[j], arr[j + 1]);}}}}
};class QuickSort : public SortStrategy {
public:void sort(std::vector<int>& arr) override {quickSort(arr, 0, arr.size() - 1);}private:void quickSort(std::vector<int>& arr, int low, int high) {if (low < high) {int pivot = arr[high];int i = low - 1;for (int j = low; j < high; ++j) {if (arr[j] < pivot) {++i;std::swap(arr[i], arr[j]);}}std::swap(arr[i + 1], arr[high]);quickSort(arr, low, i);quickSort(arr, i + 2, high);}}
};
第四步：实现上下文类

创建一个上下文类 Sorter，用于使用策略：

class Sorter {
private:SortStrategy* strategy;public:Sorter(SortStrategy* strategy) : strategy(strategy) {}void setStrategy(SortStrategy* strategy) {this->strategy = strategy;}void sort(std::vector<int>& arr) {strategy->sort(arr);}
};
策略模式 UML 图

<a class=策略模式 UML 图1" />

策略模式的 UML 图解析

  • 上下文类 (Context)：

    • Sorter 类：它是上下文类，负责使用策略并持有策略的引用。Sorter 类通过 setStrategy 方法设置具体的排序策略，并通过 sort 方法调用该策略进行排序。

  • 抽象策略类 (Strategy)：

    • SortStrategy 类：这是策略接口，定义了一个公共方法 sort，该方法由具体策略类实现。它确保所有具体策略类都有一致的接口。

  • 具体策略类 (Concrete Strategy)：

    • BubbleSort 类：实现了 SortStrategy 接口，提供了冒泡排序的具体实现。
    • QuickSort 类：实现了 SortStrategy 接口，提供了快速排序的具体实现。

例二：逐步重构并引入策略模式

第一步：初始实现

首先，从一个简单的实现开始，其中战斗者类直接实现道具使用逻辑。

#include <iostream>
using namespace std;class Fighter {
public:Fighter(int life) : m_life(life) {}void UseBXD() { // 使用补血丹m_life += 200;cout << "使用补血丹，生命值增加200。" << endl;}void UseDHD() { // 使用大还丹m_life += 300;cout << "使用大还丹，生命值增加300。" << endl;}void UseSHD() { // 使用守护丹m_life += 500;cout << "使用守护丹，生命值增加500。" << endl;}int GetLife() {return m_life;}private:int m_life;
};int main() {Fighter warrior(1000);cout << "初始生命值：" << warrior.GetLife() << endl;warrior.UseDHD();cout << "当前生命值：" << warrior.GetLife() << endl;warrior.UseBXD();cout << "当前生命值：" << warrior.GetLife() << endl;warrior.UseSHD();cout << "当前生命值：" << warrior.GetLife() << endl;return 0;
}
第二步：提取共性并实现策略接口

在该实现中，Fighter 类包含所有道具使用的逻辑。可以提取出道具使用的共性，定义一个道具策略接口。

class ItemStrategy {
public:virtual void UseItem(Fighter* fighter) = 0;virtual ~ItemStrategy() {}
};
第三步：实现具体策略类

为每种道具创建具体的策略类，实现 ItemStrategy 接口。

  • 补血丹策略类：
class ItemStrategy_BXD : public ItemStrategy {
public:void UseItem(Fighter* mainobj) override {mainobj->SetLife(mainobj->GetLife() + 200); // 补充200点生命值}
};
  • 大还丹策略类：
class ItemStrategy_DHD : public ItemStrategy {
public:void UseItem(Fighter* mainobj) override {mainobj->SetLife(mainobj->GetLife() + 300); // 补充300点生命值}
};
  • 守护丹策略类：
class ItemStrategy_SHD : public ItemStrategy {
public:void UseItem(Fighter* mainobj) override {mainobj->SetLife(mainobj->GetLife() + 500); // 补充500点生命值}
};
第四步：实现上下文类：

在 Fighter 类中添加设置道具策略的方法，并移除具体的道具使用逻辑，并定义战斗者的子类（可以不需要字类）。

class Fighter {
public:Fighter(int life) : m_life(life), itemStrategy(nullptr) {}void SetItemStrategy(ItemStrategy* strategy) {itemStrategy = strategy;}void UseItem() {if (itemStrategy) {itemStrategy->UseItem(this);}}int GetLife() {return m_life;}void SetLife(int life) {m_life = life;}private:int m_life;ItemStrategy* itemStrategy;
};
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) {}// 其他法师特有的方法
};
第五步：更新主函数

更新主函数以使用新的策略模式结构。

int main() {Fighter warrior(1000);cout << "初始生命值：" << warrior.GetLife() << endl;ItemStrategy* strategy1 = new ItemStrategy_DHD();warrior.SetItemStrategy(strategy1);warrior.UseItem();cout << "当前生命值：" << warrior.GetLife() << endl;ItemStrategy* strategy2 = new ItemStrategy_BXD();warrior.SetItemStrategy(strategy2);warrior.UseItem();cout << "当前生命值：" << warrior.GetLife() << endl;ItemStrategy* strategy3 = new ItemStrategy_SHD();warrior.SetItemStrategy(strategy3);warrior.UseItem();cout << "当前生命值：" << warrior.GetLife() << endl;delete strategy1;delete strategy2;delete strategy3;return 0;
}

策略模式 UML 图

<a class=策略模式 UML 图2" />

策略模式的 UML 图解析
  • Context(环境类)：也叫上下文类，是使用算法的角色，该类中维持着一个对抽象策略类的指针或引用。这里指Fighter类。
  • Stategy(抽象策略类)：定义所支持的算法的公共接口，是所有策略类的父类。这里指 ItemStrategy 类。
  • ConcreteStrategy(具体策略类)：抽象策略类的子类，实现抽象策略类中声明的接口。这里指ItemStrategy_BXD、ItemStrategy_DHD、ItemStrategy_SHD类。

策略模式优缺点

优点：

  • 灵活性：可以在运行时选择不同的策略，增加了程序的灵活性和可扩展性。

  • 开放-关闭原则：新的策略可以通过实现策略接口而无需修改现有代码，符合开放-关闭原则。

  • 清晰的职责分离：将不同的算法封装在不同的类中，使得代码更加清晰，易于维护。

  • 减少条件语句：避免了使用大量的条件语句（如 if-else 或 switch），使代码结构更加简洁。

  • 易于测试：每个策略类可以独立测试，便于单元测试和调试。

缺点：

  • 类的数量增加：每种策略都需要一个新的类，可能导致类的数量增加，增加了系统的复杂性。

  • 客户端必须了解所有策略：客户端需要了解所有可用的策略，以便选择合适的策略，这可能增加了使用的复杂性。

  • 性能开销：在某些情况下，频繁地创建和销毁策略对象可能导致性能开销。

  • 不适合简单的算法：对于简单的算法，使用策略模式可能显得过于复杂，增加了不必要的抽象。

策略模式适用场景

  • 多种算法：当有多个算法可以选择时，策略模式可以将它们封装起来，方便切换。
  • 避免条件语句：当使用大量条件语句来选择算法时，可以使用策略模式来简化代码结构。
  • 动态选择算法：当需要在运行时选择算法时，策略模式提供了灵活性。
  • 算法复用：当多个类需要使用同一算法时，可以将算法封装成策略类，促进代码复用。

例一的完整代码

以下是完整的实现代码：

#include <iostream>
#include <vector>// 策略接口
class SortStrategy
{
public:virtual void sort(std::vector<int>& arr) = 0; // 策略接口
};// 具体策略：冒泡排序
class BubbleSort : public SortStrategy {
public:void sort(std::vector<int>& arr) override {for (size_t i = 0; i < arr.size() - 1; ++i) {for (size_t j = 0; j < arr.size() - i - 1; ++j) {if (arr[j] > arr[j + 1]) {std::swap(arr[j], arr[j + 1]);}}}}
};// 具体策略：快速排序
class QuickSort : public SortStrategy {
public:void sort(std::vector<int>& arr) override {quickSort(arr, 0, arr.size() - 1);}private:void quickSort(std::vector<int>& arr, int low, int high) {if (low < high) {int pivot = arr[high];int i = low - 1;for (int j = low; j < high; ++j) {if (arr[j] < pivot) {++i;std::swap(arr[i], arr[j]);}}std::swap(arr[i + 1], arr[high]);quickSort(arr, low, i);quickSort(arr, i + 2, high);}}
};// 上下文类
class Sorter {
private:SortStrategy* strategy;public:Sorter(SortStrategy* strategy) : strategy(strategy) {}void setStrategy(SortStrategy* strategy) {this->strategy = strategy;}void sort(std::vector<int>& arr) {strategy->sort(arr);}
};// 示例用法
int main() {std::vector<int> data = {5, 3, 8, 6, 2};Sorter sorter(new BubbleSort());sorter.sort(data); // 使用冒泡排序sorter.setStrategy(new QuickSort());sorter.sort(data); // 使用快速排序return 0;
}

例二的完整代码

#include <iostream>
using namespace std;class Fighter; // 类前向声明//道具策略类的父类
class ItemStrategy
{
public:virtual void UseItem(Fighter* mainobj) = 0;virtual ~ItemStrategy() {}
};//战斗者父类
class Fighter
{
public:Fighter(int life, int magic, int attack) :m_life(life), m_magic(magic), m_attack(attack) {}virtual ~Fighter() {}public:void SetItemStrategy(ItemStrategy* strategy) //设置道具使用的策略{itemstrategy = strategy;}void UseItem() //使用道具（吃药）{itemstrategy->UseItem(this);}int  GetLife() //获取人物生命值{return m_life;}void SetLife(int life) //设置人物生命值{m_life = life;}private:ItemStrategy* itemstrategy = nullptr; //C++11中支持这样初始化protected:int m_life;int m_magic;int m_attack;
};//“战士”类，父类为Fighter
class F_Warrior :public Fighter
{
public:F_Warrior(int life, int magic, int attack) :Fighter(life, magic, attack) {}
};//“法师”类，父类为Fighter
class F_Mage :public Fighter
{
public:F_Mage(int life, int magic, int attack) :Fighter(life, magic, attack) {}
};//补血丹策略类
class ItemStrategy_BXD : public ItemStrategy
{
public:virtual void UseItem(Fighter* mainobj){mainobj->SetLife(mainobj->GetLife() + 200); //补充200点生命值cout << "使用补血丹，生命值增加200。" << endl;}
};//大还丹策略类
class ItemStrategy_DHD : public ItemStrategy
{
public:virtual void UseItem(Fighter* mainobj){mainobj->SetLife(mainobj->GetLife() + 300); //补充300点生命值cout << "使用大还丹，生命值增加300。" << endl;}
};//守护丹策略类
class ItemStrategy_SHD : public ItemStrategy
{
public:virtual void UseItem(Fighter* mainobj){mainobj->SetLife(mainobj->GetLife() + 500); //补充500点生命值cout << "使用守护丹，生命值增加500。" << endl;}
};int main()
{// 创建战斗者对象Fighter* prole_war = new Fighter(1000, 0, 200);// 打印初始生命值cout << "初始生命值：" << prole_war->GetLife() << endl;// 使用大还丹ItemStrategy* strategy1 = new ItemStrategy_DHD();prole_war->SetItemStrategy(strategy1);prole_war->UseItem();cout << "当前生命值：" << prole_war->GetLife() << endl;// 使用补血丹ItemStrategy* strategy2 = new ItemStrategy_BXD();prole_war->SetItemStrategy(strategy2);prole_war->UseItem();cout << "当前生命值：" << prole_war->GetLife() << endl;// 使用守护丹ItemStrategy* strategy3 = new ItemStrategy_SHD();prole_war->SetItemStrategy(strategy3);prole_war->UseItem();cout << "当前生命值：" << prole_war->GetLife() << endl;// 释放资源delete strategy1;delete strategy2;delete strategy3;delete prole_war;F_Mage mage(800, 300, 100);cout << "法师初始生命值：" << mage.GetLife() << endl;// 可以为法师设置道具策略并使用// ...return 0;
}

http://www.ppmy.cn/embedded/98690.html

相关文章

【区块链+金融服务】“吉惠通”一站式金融综合服务平台 | FISCO BCOS应用案例

【区块链+金融服务】“吉惠通”一站式金融综合服务平台 | FISCO BCOS应用案例

释放数据要素价值&#xff0c;FISCO BCOS 2024 应用案例征集 核心企业拥有良好的企业信誉&#xff0c;但有时会由于无可传递的信任背书&#xff0c;而无法为其他环节供应商提供融资支持&#xff0c;无 法促进产业链条良性发展&#xff1b;金融机构难以得到有议价空间的、弹性的…
阅读更多...
Apache Flink细粒度资源管理原理

Apache Flink细粒度资源管理原理

粗粒度资源管理 Apache Flink 1.1.4版本之前使用的是粗粒度的资源管理&#xff0c;即每个算子Slot Request所需要的资源都是未知的&#xff0c;Flink内部用UNKNOWN的特殊值来表示&#xff0c;这个值可以和任意资源规则的物理Slot匹配&#xff0c;站在Taskmanager的角度&#x…
阅读更多...
MySQL键分区分区表

MySQL键分区分区表

什么是键分区分区表&#xff1f; 键分区是一种MySQL数据库中的分区策略&#xff0c;它基于某个列的键值将数据分割成不同的分区。每个键值都会被映射到一个唯一的分区&#xff0c;这样可以确保数据在不同分区中均匀分布。键分区广泛应用于MySQL Cluster环境中&#xff0c;它可…
阅读更多...
Ruby模板引擎：构建动态视图的艺术

Ruby模板引擎：构建动态视图的艺术

标题&#xff1a;Ruby模板引擎&#xff1a;构建动态视图的艺术 在Ruby on Rails的世界里&#xff0c;模板引擎是构建动态网页的基石。它们允许开发者将服务器端的逻辑嵌入到HTML中&#xff0c;实现数据的动态展示。本文将深入探讨Ruby中几种常用的模板引擎&#xff0c;包括ERB…
阅读更多...
JAVA_7

JAVA_7

JAVA_7 JAVA面向对象编程1. 抽象方法和抽象类 JAVA面向对象编程 1. 抽象方法和抽象类 使用abstract修饰的方法&#xff0c;没有方法体&#xff0c;只有声明。定义的是一种“规范”&#xff0c;就是告诉子类必须要给抽象方法提供具体的实现。包含抽象方法的类就是抽象类。通过…
阅读更多...
鸿蒙内核源码分析(异常接管篇) | 社会很单纯，复杂的是人

鸿蒙内核源码分析(异常接管篇) | 社会很单纯，复杂的是人

为何要有异常接管? 拿小孩成长打比方&#xff0c;大人总希望孩子能健康成长&#xff0c;但在成长过程中总会遇到各种各样的问题&#xff0c;树欲静而风不止&#xff0c;成长路上有危险&#xff0c;有时是自己的问题有时是外在环境问题.就像抖音最近的流行口水歌一样&#xff…
阅读更多...
autocommit自动提交事务及commit、rollback用法

autocommit自动提交事务及commit、rollback用法

MySQL默认开启事务自动提交&#xff0c;每条SQL语句都会被当做一个单独的事务自动执行。 一、查看autocommit自动提交事物状态 SHOW VARIABLES LIKE ‘autocommit’; 1、开启状态&#xff1a;ON autocommit的值为ON&#xff0c;表示系统开启自动提交模式 2、关闭状态&#…
阅读更多...
有了这4款工具，你就知道电脑怎么录屏了！

有了这4款工具，你就知道电脑怎么录屏了！

电脑屏幕录屏这个问题很多人都会碰到&#xff0c;比如教学视频录制&#xff0c;游戏技巧分享&#xff0c;软件操作演示等等。因为场景众多&#xff0c;电脑自带的录屏功能不一定能满足&#xff0c;所以借助第三方工具是一个很有效的办法。如果大家不知道如何录屏&#xff0c;可…
阅读更多...
最新文章

Copyright @ 2022~2023