一 定义
策略模式是指定义一系列的算法，把它们一个个封装起来，并且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。也就是说这些算法所完成的功能一样，对外的接口一样，只是各自实现上存在差异。
策略模式把对象本身和运算规则区分开来，其功能非常强大，因为这个设计模式本身的核心思想就是面向对象编程的多形性的思想。
二 ULM图
环境类(Context):用一个ConcreteStrategy对象来配置。维护一个对Strategy对象的引用。可定义一个接口来让Strategy访问它的数据。
抽象策略类(Strategy):定义所有支持的算法的公共接口。 Context使用这个接口来调用某ConcreteStrategy定义的算法。
具体策略类(ConcreteStrategy):以Strategy接口实现某具体算法。
三 策略模式的优点和缺点及可用场景
1、策略模式的优点
（1）策略模式是一种定义一系列算法的方法，从概念上来看，所有这些算法完成的都是相同的工作，只是实现不同，他可以以相同的方式调用所有的算法，减少了各种算法类与使用算法类之间的耦合。
（2）策略模式的Strategy类曾是为Context定义了一些列的可供重用的算法或行为。集成有助于析取出这些算法中的公共功能。
（3）策略模式简化了单元测试，因为每个算法都有自己的类，可以通过自己的接口单独测试。
（4）策略模式就是用来封装算法的。
（5）只要在分析过程中听到需要在不同时间应用不同的业务规则，就可以考虑使用策略模式处理这种变化的可能性。
（6）简单工厂模式需要让客户端认识两个类，而策略模式和简单工厂模式结合的用法，客户端只需要认识一个类Context即可。
2、策略模式的缺点
- 客户端必须知道所有的策略类，并自行决定使用哪一个策略类: 本模式有一个潜在的缺点，就是一个客户要选择一个合适的Strategy就必须知道这些Strategy到底有何不同。此时可能不得不向客户暴露具体的实现问题。因此仅当这些不同行为变体与客户相关的行为时 , 才需要使用Strategy模式。
- Strategy和Context之间的通信开销 ：无论各个ConcreteStrategy实现的算法是简单还是复杂, 它们都共享Strategy定义的接口。因此很可能某些 ConcreteStrategy不会都用到所有通过这个接口传递给它们的信息；简单的 ConcreteStrategy可能不使用其中的任何信息！这就意味着有时Context会创建和初始化一些永远不会用到的参数。如果存在这样问题 , 那么将需要在Strategy和Context之间更进行紧密的耦合。
- 策略模式将造成产生很多策略类：可以通过使用享元模式在一定程度上减少对象的数量。 增加了对象的数目 Strategy增加了一个应用中的对象的数目。有时你可以将 Strategy实现为可供各Context共享的无状态的对象来减少这一开销。任何其余的状态都由 Context维护。Context在每一次对Strategy对象的请求中都将这个状态传递过去。共享的 Strategy不应在各次调用之间维护状态。
3、策略模式的可用场景及注意事项
- 当一组算法对应一个任务，并且程序可以在运行时灵活的选择其中一个算法，策略模式是很好的选择。
- 需要安全的封装平等的多种不同类型操作
- 当同一抽象类拥有很多具体子类时且程序运行的时候需要动态决定使用哪一具体类时
- 策略模式的重心不是如何实现算法，而是关注如何组织、调用这些算法，从而让程序结构更灵活，具有更好的维护性和扩展性。
- 策略模式中各个策略算法的平等性。对于一系列具体的策略算法，大家的地位是完全一样的，正因为这个平等性，才能实现算法之间可以相互替换。所有的策略算法在实现上也是相互独立的，相互之间是没有依赖的。
- 运行时策略的互斥性，策略模式在运行的每一个时刻只能使用这组被封装算法中的某一个，虽然可以动态地在不同的策略实现中切换，但是同时只能使用一个。
- 策略的抽象实现，当所有的具体策略类都有一些公有的行为。此时根据设计原则应把这些公有的行为放到共同的抽象策略角色Strategy类里面。
实例
1. 高速缓存（Cache）算法
什么是Cache的替换算法呢？简单解释一下， 当发生Cache缺失时，Cache控制器必须选择Cache中的一行，并用欲获得的数据来替换它。所采用的选择策略就是Cache的替换算法。下面给出相应的UML图。
ReplaceAlgorithm是一个抽象类，定义了算法的接口，有三个类继承自这个抽象类，也就是具体的算法实现。Cache类中需要使用替换算法，因此维护了一个 ReplaceAlgorithm的对象。这个UML图的结构就是策略模式的典型结构。下面根据UML图，给出相应的实现。
首先给出替换算法的定义。
//抽象接口
class ReplaceAlgorithm
{
public:
virtual void Replace() = 0;
};
//三种具体的替换算法
class LRU_ReplaceAlgorithm : public ReplaceAlgorithm
{
public:
void Replace() { cout<<"Least Recently Used replace algorithm"<<endl; }
};
class FIFO_ReplaceAlgorithm : public ReplaceAlgorithm
{
public:
void Replace() { cout<<"First in First out replace algorithm"<<endl; }
};
class Random_ReplaceAlgorithm: public ReplaceAlgorithm
{
public:
void Replace() { cout<<"Random replace algorithm"<<endl; }
};
接着给出Cache的定义，这里很关键，Cache的实现方式直接影响了客户的使用方式，其关键在于如何指定替换算法。
//Cache需要用到替换算法
template <class RA>
class Cache
{
private:
RA m_ra;
public:
Cache() { }
~Cache() { }
void Replace() { m_ra.Replace(); }
};
int main()
{
Cache<Random_ReplaceAlgorithm> cache; //模板实参
cache.Replace();
return 0;
}
2. 商店促销
#include <iostream>
#include <string>
#include <cmath>
#include <memory>
//父类抽象类
class CashSuper
{
public:
virtual double acceptCash(double) = 0;
virtual ~CashSuper() = default;
};
//子类：正常付费类型
class CashNormal:public CashSuper
{
public:
double acceptCash(double money)
{
return money;
}
};
//子类：返现类型
class CashReturn:public CashSuper
{
private:
double moneyCondition;
double moneyReturn;
public:
CashReturn(double moneyCondition,double moneyReturn)
{
this->moneyCondition=moneyCondition;
this->moneyReturn=moneyReturn;
}
double acceptCash(double money)
{
double result=money;
if(money>moneyCondition)
result=money - std::floor(money/moneyCondition)*moneyReturn;
return result;
}
};
//子类：打折扣类型
class CashRebate:public CashSuper
{
private:
double moneyRebate;
public:
CashRebate(double moneyRebate)
{
this->moneyRebate=moneyRebate;
}
double acceptCash(double money)
{
return money*moneyRebate;
}
};
enum SellStrategy
{
normal,
returnMoney,
rebate
};
class CashContext
{
private:
std::unique_ptr<CashSuper> cs;
public:
CashContext(int type)
{
switch(type)
{
case SellStrategy::normal:
{
cs = std::make_unique<CashNormal>();
break;
}
case SellStrategy::returnMoney:
{
cs = std::make_unique<CashReturn>(300,100);
break;
}
case SellStrategy::rebate:
{
cs = std::make_unique<CashRebate>(0.8);
break;
}
default:;
}
}
double GetResult(double money)
{
return cs->acceptCash(money);
}
};
int main(void)
{
double total=0;
double totalPrices=0;
//正常收费
auto cc1 = std::make_unique<CashContext>(SellStrategy::normal);
totalPrices=cc1->GetResult(300);
total+=totalPrices;
std::cout<<"Type:正常收费 totalPrices:"<<totalPrices<<" total:"<<total<<std::endl;
totalPrices=0;
//返现类型
auto cc2 = std::make_unique<CashContext>(SellStrategy::returnMoney);
totalPrices=cc2->GetResult(700);
total+=totalPrices;
std::cout<<"Type:满300返100 totalPrices:"<<totalPrices<<" total:"<<total<<std::endl;
totalPrices=0;
//打折类型
auto cc3 = std::make_unique<CashContext>(SellStrategy::rebate);
totalPrices=cc3->GetResult(300);
total+=totalPrices;
std::cout<<"Type:打8折 totalPrices:"<<totalPrices<<" total:"<<total<<std::endl;
totalPrices=0;
return 0;
}
运行结果如下：
与其他模式
1）状态模式
策略模式和其它许多设计模式比较起来是非常类似的。策略模式和状态模式最大的区别就是策略模式只是的条件选择只执行一次，而状态模式是随着实例参数（对象实例的状态）的改变不停地更改执行模式。换句话说，策略模式只是在
对象初始化的时候更改执行模式，而状态模式是根据对象实例的周期时间而动态地改变对象实例的执行模式。
- 可以通过环境类状态的个数来决定是使用策略模式还是状态模式。
- 策略模式的环境类自己选择一个具体策略类，具体策略类无须关心环境类；而状态模式的环境类由于外在因素需要放进一个具体状态中，以便通过其方法实现状态的切换，因此环境类和状态类之间存在一种双向的关联关系。
- 使用策略模式时，客户端需要知道所选的具体策略是哪一个，而使用状态模式时，客户端无须关心具体状态，环境类的状态会根据用户的操作自动转换。
- 如果系统中某个类的对象存在多种状态，不同状态下行为有差异，而且这些状态之间可以发生转换时使用状态模式；
- 如果系统中某个类的某一行为存在多种实现方式，而且这些实现方式可以互换时使用策略模式。
2）简单工厂模式的区别
工厂模式是创建型模式 ，它关注对象创建，提供创建对象的接口. 让对象的创建与具体的使用客户无关。
策略模式是对象行为型模式 ，它关注行为和算法的封装 。它定义一系列的算法,把每一个算法封装起来, 并且使它们可相互替换。使得算法可独立于使用它的客户而变化。
总结与分析
1）策略模式是一个比较容易理解和使用的设计模式，策略模式是对算法的封装，它把算法的责任和算法本身分割开，委派给不同的对象管理。策略模式通常把一个系列的算法封装到一系列的策略类里面，作为一个抽象策略类的子类。用一句话来说，就是“准备一组算法，并将每一个算法封装起来，使得它们可以互换”。
2）在策略模式中，应当由客户端自己决定在什么情况下使用什么具体策略角色。
3）策略模式仅仅封装算法，提供新算法插入到已有系统中，以及老算法从系统中“退休”的方便，策略模式并不决定在何时使用何种算法，算法的选择由客户端来决定。这在一定程度上提高了系统的灵活性，但是客户端需要理解所有具体策略类之间的区别，以便选择合适的算法，这也是策略模式的缺点之一，在一定程度上增加了客户端的使用难度。