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

于 2024-08-19 00:45:02 发布
阅读量932 收藏 10
点赞数 18
分类专栏： C++ 新经典：设计模式 文章标签： c++ 设计模式 策略模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_68194402/article/details/141307272
版权

策略模式

策略模式

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

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

主要组成部分

  • 策略接口 (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 图

策略模式 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 图

策略模式 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;
}
不是仙人的闲人
关注
  • 18
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++设计模式——策略模式（strategy pattern）
净无邪博客
03-21 942
一、原理讲解 1.1意图 定义算法簇，将这些算法封装起来，之间可以相互替换。这样的好处在于，使得算法可以独立于使用它的客户而变化。 1.2与模板方法区别 模板方法主要是继承接口类，而策略模式主要是组合接口类，两种方法核心区别在于，是继承？还是组合？ 设计模式八大原则之一：优先使用对象组合，而不是类继承。 1.3设计步骤 a1 先定义一个接口类最为抽象基类ABC a2 定义一系列算法...
C++设计模式--基于Qt4开源跨平台开发框架
01-06
《C++设计模式--基于Qt4开源跨平台开发框架》一书主要探讨了如何在C++编程中利用设计模式，并结合Qt4框架进行高效的跨平台应用开发。设计模式是软件工程中的重要概念，它们是经过时间和实践验证的解决特定问题的模板...
c++ 设计模式——策略模式
weixin_44767770的博客
03-27 192
c++设计模式——策略模式 定义 策略模式定义了一系列的算法，并将每一个算法封装起来，而且使它们相互之间可以替换。策略模式让算法独立于使用它的客户而独立变化。 角色 抽象策略角色（strategy）：抽象策略类 具体策略角色（concrete strategy）：封装了相关的算法和行为 环境角色（context）：持有一个策略类的引用，最终给客户端调用 模式图 应用场景 ...
C++设计模式——策略模式(Strategy Pattern)
leonardohaig的博客
05-30 2683
C++设计模式——策略模式(Strategy Pattern) 微信公众号：幼儿园的学霸 目录 文章目录C++设计模式——策略模式(Strategy Pattern)目录定义实现示例传统的策略模式实现使用函数指针实现策略模式工厂模式和策略模式对比总结参考资料 定义 Define a family of algorithms,encapsulate each one,and make them interchangeable. 定义一组算法，将每个算法都封装起来，并且使它们之间可以互换 策略模式是指定
【Strategy模式】C++设计模式——策略模式
不负AC不负卿的博客
07-14 1470
c++策略模式、Strategy模式，以最简单的示例、代码讲解策略模式，对比分析优缺点
C++设计模式——适配器模式
Abieai的博客
10-14 543
设计模式分为三大类： 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。主要实现了适配器模式。
c++设计模式GoF23
10-28
### c++设计模式GoF23 #### 0. 引言 - **设计模式的重要性**：“Next to My Life, Software Is My Passion”——Robert C. Martin 的名言揭示了软件设计的重要地位。掌握设计模式意味着理解面向对象分析与设计...
设计模式实现——观察者模式
09-04
在《设计模式实现——观察者模式》这篇博客中，作者可能详细解释了观察者模式的概念、结构以及其在实际编程中的应用。以下是对观察者模式的详细阐述： 1. **模式定义**：观察者模式是一种对象行为型模式，它允许...
设计模式C++版
06-13
设计模式C++版文档主要聚焦于面向对象设计与分析的核心——设计模式，并以C++语言实现为示范。这份文档详尽阐述了23种GoF（Gang of Four）设计模式，并结合具体的C++源码示例，旨在帮助读者深入理解并掌握这些设计...
C++ 策略模式 dome
04-19
策略模式是一种行为设计模式，它使你能在运行时改变对象的行为。在C++中，策略模式通常通过定义一系列算法类并让它们之间可以互换来实现。这些算法都封装在一个接口或抽象基类中，使得客户端代码可以独立于具体算法...
C++匿名函数lamba简介
yao_tao11的博客
08-18 510
Lambda 表达式是 C++11 引入的一个功能，允许你在代码中定义匿名函数（即没有名字的函数）。这种表达式可以用于简化函数对象的定义，并使得代码更简洁。Lambda 表达式特别适用于局部的、一次性的函数对象，如用于 STL 算法中。捕获方式含义[ ]空捕获列表，Lambda不能使用所在函数中的变量.[names]names是一个逗号分隔的名字列表，这些名字都是Lambda所在函数的局部变量。默认情况下，这些变量会被拷贝，然后按值传递，名字前面如果使用了&，则按引用传递[&]
c++编程（22）——STL（6）set
2301_77239666的博客
08-16 1027
欢迎来到博主的专栏——c++编程博主ID：代码小豪。
【漫谈C语言和嵌入式011】嵌入式系统中常用的校验方式
最新发布
2403_83044722的博客
08-18 336
在嵌入式系统中，选择合适的校验方式取决于应用场景的需求。简单的数据传输可以使用奇偶校验或校验和，而对于更复杂、更可靠的数据传输，CRC和汉明码则是更好的选择。
C++ | Leetcode C++题解之第337题打家劫舍III
Ddddddd_158的博客
08-15 328
C++ | Leetcode C++题解之第337题打家劫舍III
C语言典型例题43
2302_77517102的博客
08-18 267
有一个函数：y={x,x
【C语言】字符串操作函数详解
EleganceJiaBao的博客
08-14 1032
这些头文件提供了字符串操作所需的函数声明。以下是常用字符串操作函数的详细讲解，包括每个函数的参数、返回值说明以及示例代码。每个函数的使用说明还包括了适当的表格以帮助理解其功能和用法。
C++_基本语法笔记_模板
qq_45629864的博客
08-14 430
思想是Java里的泛型（不确定用什么类型的数据）这里template这一句，意思是声明T是泛型，后面写用到泛型T的函数。建议都用应用场景：不同数据类型的交换函数。
C++编译器对类模板的按需实例化
2301_76197086的博客
08-16 122
简析C++类模板的按需实例化
typdef 与 struct
ligreenjian的博客
08-14 129
int age;int num;//每使用一次就要多一个struct。使用typdef就简洁些。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值