新版MQL语言程序设计：策略模式的原理、应用及代码实现

文章目录

- 一、什么是策略模式
- 二、策略模式的实现原理
- 三、策略模式的应用场景
- 四、策略模式的代码实现

一、什么是策略模式

策略模式是一种行为型设计模式，它允许在运行时根据不同的情况选择算法的行为。该模式将算法封装成独立的类，并使它们可以互相替换，从而使算法的变化独立于使用算法的客户端。

二、策略模式的实现原理

定义一个策略接口：首先需要定义一个策略接口，该接口声明了算法的方法。
实现具体策略类：针对不同的算法，实现具体的策略类，这些类都实现了策略接口，并提供了自己的算法实现。
在客户端使用策略：在客户端代码中，创建一个策略对象，并将其传递给需要使用算法的对象。客户端代码不需要关心具体的算法实现，只需要知道如何使用策略对象即可。
运行时动态切换策略：由于策略对象是可以相互替换的，因此在运行时可以根据需要动态切换策略对象，从而改变算法的行为。

通过使用策略模式，可以将算法的实现与客户端代码解耦，使得算法可以独立变化，而不影响客户端代码的稳定性和可维护性。

三、策略模式的应用场景

当一个系统需要在多个算法中选择一个进行使用时，可以使用策略模式。例如，一个电商平台可能需要根据用户的购买记录选择不同的推荐算法。
当一个类有多个行为或算法，并且这些行为或算法可能在未来发生变化时，可以使用策略模式。通过将每个行为或算法封装成一个策略类，可以方便地添加、修改或删除这些行为或算法。
当一个系统需要动态地切换算法时，可以使用策略模式。例如，一个游戏中的角色可能需要根据当前状态选择不同的攻击策略。
当一个系统需要对外提供一组可替换的算法时，可以使用策略模式。通过定义一个公共接口，并让每个策略类实现该接口，可以方便地切换不同的算法。

四、策略模式的代码实现

//   structure
//
//                        strategy
//   |     Context      |o-------->|      Strategy      |
//   |------------------|          |--------------------|
//   |ContextInterface()|          |AlgorithmInterface()|
//                                           ^
//                                           |
//                  +------------------------+----------------------+
//                  |                        |                      |
//        | ConcreteStrategyA  |  | ConcreteStrategyB  |  | ConcreteStrategyC  |
//        |--------------------|  |--------------------|  |--------------------|
//        |AlgorithmInterface()|  |AlgorithmInterface()|  |AlgorithmInterface()|
//
interface Strategy
{void AlgorithmInterface(void);
};
//
class ConcreteStrategyA : public Strategy
{public:void              AlgorithmInterface(void);
};
//
void ConcreteStrategyA::AlgorithmInterface(void)
{Print("executing algorithm of strategy a (",&this,")");
}
//
class ConcreteStrategyB : public Strategy
{public:void              AlgorithmInterface(void);
};
//
void ConcreteStrategyB::AlgorithmInterface(void)
{Print("executing algorithm of strategy b (",&this,")");
}
//
class ConcreteStrategyC : public Strategy
{public:void              AlgorithmInterface(void);
};
//
void ConcreteStrategyC::AlgorithmInterface(void)
{Print("executing algorithm of strategy c (",&this,")");
}
//
class Context
{public:Context(Strategy& strategy);~Context(void);void              ContextInterface(void);protected:Strategy*         m_strategy;
};
//
Context::Context(Strategy &strategy)
{m_strategy = &strategy;Print("new strategy ", &strategy, " loaded");
}
//
Context::~Context()
{if (CheckPointer(m_strategy) == 1)delete m_strategy;
}
//
void Context::ContextInterface(void)
{Print("requesting strategy algorithm");m_strategy.AlgorithmInterface();
}
//
void OnStart()
{Context *context;//---strategy acontext=new Context(new ConcreteStrategyA());context.ContextInterface();delete context;//---strategy bcontext = new Context(new ConcreteStrategyB());context.ContextInterface();delete context;//---strategy ccontext = new Context(new ConcreteStrategyC());context.ContextInterface();delete context;
}
//   output
//
//   new strategy 2097152 loaded
//   requesting strategy algorithm
//   executing algorithm of strategy a (2097152)
//   new strategy 4194304 loaded
//   requesting strategy algorithm
//   executing algorithm of strategy b (4194304)
//   new strategy 6291456 loaded
//   requesting strategy algorithm
//   executing algorithm of strategy c (6291456)