设计模式

Strategy 策略模式

动机（Motivation）

在软件构建过程中，某些对象使用的算法可能多种多样，经常改变，如果将这些算法都编码到对象中，将会使对象变得异常复杂；而且有时候支持不使用的算法也是一个性能负担。
如何在运行时根据需要透明地更改对象的算法？将算法与对象本身解耦，从而避免上述问题？

示例：不同国家的税法计算算法

 1 enum TaxBase {
 2     CN_Tax,
 3     US_Tax,
 4     DE_Tax,
 5     FR_Tax       //更改
 6 };
 7 
 8 class SalesOrder{
 9     TaxBase tax;
10 public:
11     double CalculateTax(){
12         //...
13         
14         if (tax == CN_Tax){
15             //CN***********
16         }
17         else if (tax == US_Tax){
18             //US***********
19         }
20         else if (tax == DE_Tax){
21             //DE***********
22         }
23         else if (tax == FR_Tax){  //更改
24             //...
25         }
26 
27         //....
28      }
29     
30 };

strategy1.cpp

通过if-else来判断不同国家的税法来执行对应的算法，静态的来看，以上程序并无异常，但是加上时间轴，动态地看，日后要新增其他国家的税法计算，以上源码更改如下：

1.新增一个国家枚举类型；

2.补充if-else；

但是这种做法违反了“开闭原则” — “对扩展开放，对更改封闭”，类模块应该以扩展的方式来应对未来的变化，而不是通过更改源码来应对变化。

使用策略模式修改示例：

 1 class TaxStrategy{
 2 public:
 3     virtual double Calculate(const Context& context)=0;
 4     virtual ~TaxStrategy(){}
 5 };
 6 
 7 
 8 class CNTax : public TaxStrategy{
 9 public:
10     virtual double Calculate(const Context& context){
11         //***********
12     }
13 };
14 
15 class USTax : public TaxStrategy{
16 public:
17     virtual double Calculate(const Context& context){
18         //***********
19     }
20 };
21 
22 class DETax : public TaxStrategy{
23 public:
24     virtual double Calculate(const Context& context){
25         //***********
26     }
27 };
28 
29 
30 
31 //扩展
32 //*********************************
33 class FRTax : public TaxStrategy{
34 public:
35     virtual double Calculate(const Context& context){
36         //.........
37     }
38 };
39 
40 
41 class SalesOrder{
42 private:
43     TaxStrategy* strategy;
44 
45 public:
46     SalesOrder(StrategyFactory* strategyFactory){
47         this->strategy = strategyFactory->NewStrategy();
48     }
49     ~SalesOrder(){
50         delete this->strategy;
51     }
52 
53     public double CalculateTax(){
54         //...
55         Context context();
56         
57         double val = 
58             strategy->Calculate(context); //多态调用
59         //...
60     }
61     
62 };

strategy2.cpp

将各个国家税法的算法写成TaxStrategy的子类

模式定义

定义一系列算法，把它们一个个封装起来，并且使它们可互相替换（变化）。该模式使得算法可独立于使用它的客户程序(稳定)而变化（扩展，子类化）。 ——《设计模式》 GoF

要点总结

Strategy及其子类为组件提供了一系列可重用的算法，从而可以使得类型在运行时方便地根据需要在各个算法之间进行切换。
Strategy模式提供了用条件判断语句以外的另一种选择，消除条件判断语句，就是在解耦合。含有许多条件判断语句的代码通常都需要Strategy模式。
如果Strategy对象没有实例变量，那么各个上下文可以共享同一个Strategy对象，从而节省对象开销。