设计模式之策略模式
1.意图
根据GOF的定义：定义一系列的算法或操作，并把它们一个个封装起来，并且使它们可以互换替换。以达到算法与业务独立开发的目的。
简单的说就是针对某个业务需求，抽象出解决问题的算法的一个个方法，然后实现封装不同的特定的算法(通过集成抽象类或接口)，在客户端需要使用这个算法的时候开业方便的替换就OK了，做到算法操作与业务逻辑解耦，降低了维护成本和易拓展。
2.动机
有时候对于某个问题会有多种的解决算法，但是如果在这个解决问题的类中定义多种的算法，会使这个类膨胀，拥有了一些不需要的属性和方法，这时没必要的，会使得类很难维护。
不用把所有的算法都塞进类中，只要在需要的时候替换上对应的算法类就ok了。
如果把算法实现集成到业务类中时会造成在增加新的算法的时候，需要修改此类，违背了设计原则-开闭原则，在开发中，一般是对原有代码封闭，对拓展开放的思想。
因此，通过以上的动机，策略模式就应运而生了。
3.模式结构与角色定义
策略模式的结构也比较简单。主要涉及到继承与委托两种关系，算法抽象，具体算法继承算法抽象类并实现算法，根据面向接口编程，Strategy委托给Context上下文，客户端调用到对应算法的时候，直接把对应的算法动态的赋给Context上下文就OK了。
- Strategy：
1.算法的抽象类或接口。抽象出算法的一个个方法，主要被算法具体类继承实现。
- ConcreteStrategyA/B/C:
1.算法的具体类。继承算法抽象类，实现算法。
- Context：
1.拥有Strategy的引用，有对应的接口调用算法。
客户端在调用算法的使用，主要是借助Context(其实就是一个委托类，用来调用对应的算法的)，直接调用对应的算法，把业务与算法解耦。
4.应用场景
- 许多相关的类只是算法实现细节有异。策略提供了一种用多个算法中的一个算法来配置一个类的方法。
- 针对某个问题有多种算法，不同时候可能使用不同的算法，要方便的替换。
- 算法与业务逻辑解耦，不想业务逻辑或客户端程序知道过多的算法实现细节。
- 一个类定义了多种行为，但是在某个问题上，使用了多个条件判断的方法来使用不同的行为，这时候可以用策略模式来消除多个条件判断。
5.模式的实现步骤与例子
- 1.将算法的抽象类或接口。抽象出算法的一个个方法。
- 2.实现算法的具体类。
- 3.创建一个拥有Strategy引用的Context类，拥有对应调用算法的方法。
下面看例子。
算法的抽象类与算法具体类：
//Strategy.hclass CalStrategy{public: virtual ~CalStrategy() {} virtual void Calculate() = 0;};class ACalStrategy : public CalStrategy{public: ~ACalStrategy(){} void Calculate() override { cout << "ACalStrategy Calculate" << endl; }};class BCalStrategy : public CalStrategy{public: ~BCalStrategy() {} void Calculate() override { cout << "BCalStrategy Calculate" << endl; }}; 在这里通过工厂方法的方式来创建出对应的算法：
class CalStrategyFactory{public: virtual ~CalStrategyFactory(){} virtual CalStrategy* CreateCalStrategy() = 0;};class ACalStrategyFactory : public CalStrategyFactory{public: ~ACalStrategyFactory(){} CalStrategy* CreateCalStrategy() override { return new ACalStrategy(); }};class BCalStrategyFactory : public CalStrategyFactory{public: ~BCalStrategyFactory() {} CalStrategy* CreateCalStrategy() override { return new BCalStrategy(); }}; Context上下文类，主要是用于算法的调用：
class Context{public: Context(CalStrategyFactory* factory){ this->calStrategy = factory->CreateCalStrategy(); } ~Context(){ delete calStrategy; } void Calculate() { //... std::cout<<"============算法开始==========="< Calculate(); std::cout<<"============算法结束==========="< 客户端调用：
#include "strategy.h"int main(){ CalStrategyFactory* factoryA = new ACalStrategyFactory(); Context* orderA = new Context(factoryA); CalStrategyFactory* factoryB = new BCalStrategyFactory(); Context* orderB = new Context(factoryB); orderA->Calculate(); orderB->Calculate(); delete factoryA; delete factoryB; system("pause"); return 0;} 运行结果：
============算法开始===========ACalStrategy Calculate============算法结束=======================算法开始===========BCalStrategy Calculate============算法结束===========
6.小结
策略方法主要是定义系列的算法，方便在需求变化时很容易的替换对应的算法，几乎是不增加什么成本的。有助于提取出算法的公共部分抽象出抽象类或接口。但是在实际使用的时候，要注意Context的使用，如果直接在里面硬编码new一个具体类的算法，就会比较生硬，没有动态性。
- 一般拥有一个strategy引用，是通过一个接口传入对应的算法具体类，达到动态的替换算法。
- 另外一种方法是把Context实现为模板类，在创建的时候直接创建对应的算法的方法。比如
Context<ACalStrategy> contex，这样就是静态绑定，这样的话丧失了运行时的动态性，但是效率会高一点。具体的选择应根据实际情况选择。