《设计模式》策略模式

Posted 2023-03-05 joker D888

策略模式

前言

先了解一下设计模式的几种类似：

• 行为型设计模式（Behavioral Design Pattern）是指一组设计模式，它们关注的是对象之间的通信和协作。行为型设计模式描述了对象之间的职责分配和算法的封装，以及如何在运行时动态改变对象的行为。它们的目的是提高系统的灵活性和可复用性，使系统更易于扩展和维护。行为型设计模式通常包括以下几种：
  1. 模板方法模式（Template Method Pattern）
  2. 策略模式（Strategy Pattern）
  3. 观察者模式（Observer Pattern）
  4. 迭代器模式（Iterator Pattern）
  5. 责任链模式（Chain of Responsibility Pattern）
  6. 命令模式（Command Pattern）
  7. 访问者模式（Visitor Pattern）
  8. 备忘录模式（Memento Pattern）
  9. 状态模式（State Pattern）
  10. 中介者模式（Mediator Pattern）
  11. 解释器模式（Interpreter Pattern）
• 创建型设计模式主要关注对象的创建过程，包括将对象的创建过程抽象化、封装和解耦等。常见的创建型设计模式包括：工厂方法模式、抽象工厂模式、单例模式、建造者模式和原型模式。
• 结构型设计模式主要关注对象的组合方式，包括对象之间的组合方式、类之间的组合方式等。常见的结构型设计模式包括：适配器模式、桥接模式、组合模式、装饰模式、外观模式、享元模式和代理模式。

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

正文

策略模式的优点包括：

1. 可以方便地增加新的算法，因为每个算法都被封装到了自己的类中，新增加一个算法只需要添加一个新的类就可以了。
2. 可以方便地切换算法，因为算法之间被解耦，所以可以方便地切换算法。
3. 可以方便地扩展算法，因为每个算法都被封装到了自己的类中，所以可以方便地扩展算法。
4. 可以减少代码重复，因为算法之间可以共享代码。
5. 可以方便地测试算法，因为每个算法都被封装到了自己的类中，所以可以方便地测试算法。

总之，策略模式可以提高代码的灵活性、可扩展性和可维护性。它的应用范围很广，可以用于各种算法的封装和应用。

#include <iostream>
#include <vector>

// 抽象策略类
class Strategy 
public:
    virtual void execute() = 0;
;

// 具体策略类A
class ConcreteStrategyA : public Strategy 
public:
    virtual void execute() 
        std::cout << "执行策略A" << std::endl;
    
;

// 具体策略类B
class ConcreteStrategyB : public Strategy 
public:
    virtual void execute() 
        std::cout << "执行策略B" << std::endl;
    
;

// 上下文类
class Context 
public:
    void setStrategy(Strategy* strategy) 
        m_strategy = strategy;
    

    void executeStrategy() 
        if (m_strategy != nullptr) 
            m_strategy->execute();
        
    

private:
    Strategy* m_strategy;
;

int main() 
    // 创建策略对象
    ConcreteStrategyA strategyA;
    ConcreteStrategyB strategyB;

    // 创建上下文对象
    Context context;

    // 执行策略A
    context.setStrategy(&strategyA);
    context.executeStrategy();

    // 执行策略B
    context.setStrategy(&strategyB);
    context.executeStrategy();

    return 0;

在上面的代码中，我们定义了一个抽象策略类 Strategy，以及两个具体的策略类 ConcreteStrategyA 和 ConcreteStrategyB。这些策略类都实现了 execute 方法，用于执行具体的策略。

我们还定义了一个上下文类 Context，它包含一个成员变量 m_strategy，用于保存当前使用的策略对象。Context 类有两个方法，setStrategy 和 executeStrategy，分别用于设置当前使用的策略对象和执行策略。

在 main 函数中，我们创建了两个具体的策略对象 strategyA 和 strategyB，以及一个上下文对象 context。我们首先将上下文对象的策略设置为 strategyA，然后调用 executeStrategy 方法执行策略。接着，我们将上下文对象的策略设置为 strategyB，再次执行策略。

这个示例中，策略模式的核心思想就是将具体的算法实现封装到不同的策略类中，通过上下文对象来控制使用哪个策略。这样，我们就可以在运行时动态地切换不同的策略，从而实现灵活的算法组合。