C++设计模式（五）- 策略模式

“组件协作”模式:
现代软件专业分工之后的第一个结果是“框架与应用程序的划分”，“组件协作”模式通过晚期绑定，来实现框架与应用程序之间的松耦合，是二者之间协作时常用的模式。
典型模式

• Template Method
• Strategy
• Observer / Event

模式定义：

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

要点总结

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

案例：
设计一个税费计算器类，支持多个国家的税法：

//枚举出各个国家。
enum TaxBase {
	CN_Tax,
	US_Tax,
};

//定义一个类，封装一个私有变量表示国家，和一个公有方法计算税费。每个国家用一个if、else分支区分。
class SalesOrder{
    TaxBase tax;
public:
    double CalculateTax(){
        //...
        
        if (tax == CN_Tax){
            //CN***********
        }
        else if (tax == US_Tax){
            //US***********
        }
        //....
     }
    
};

这样做的缺点:
耦合度高，后期要加新的国家要添加新的枚举，并修改double CalculateTax()方法。违背开闭原则。
使用策略模式：
把税费计算方法抽象到一个接口类，针对具体的国家，分别定义一个派生类继承这个接口类，并实现计算方法。用的时候，定义一个基类指针，指向派生类对象。

//接口类
class TaxStrategy{
public:
    virtual double Calculate(const Context& context)=0;
    virtual ~TaxStrategy(){}
};

//具体国家 CNTax 
class CNTax : public TaxStrategy{
public:
    virtual double Calculate(const Context& context){
        //***********
    }
};
//具体国家 USTax 
class USTax : public TaxStrategy{
public:
    virtual double Calculate(const Context& context){
        //***********
    }
};

//客户程序，
class SalesOrder{
private:
    TaxStrategy* strategy;

public:
    SalesOrder(StrategyFactory* strategyFactory){
        this->strategy = strategyFactory->NewStrategy();
    }

    public double CalculateTax(){
        //...
        Context context();
        
        double val = strategy->Calculate(context); //根据传进来具体strategy，调用派生类的算法。（多态）
        //...
    }
    
};

案例2：
简单计算器：

#include <iostream>
using namespace std;

//定义一个接口类
class ICalc
{
public:
    virtual int retValue() = 0;
    virtual void setOperators(int a, int b) = 0;
    //virtual ~ICalc() = 0;
};

//定义加法类
class AddCalc:public ICalc
{
public:
    virtual void setOperators(int a, int b)
    {
        this->a = a;
        this->b = b;
    };
    virtual int retValue()
    {
        return a+b;
    };
private:
    int a;
    int b;

};
//定义减法类
class SubCalc: public ICalc
{
public:
    void setOperators(int a, int b)
    {
        this->a = a;
        this->b = b;
    };
    int retValue()
    {
        return a-b;
    };

private:
    int a;
    int b;
};

int main()
{
    ICalc * calculor = new AddCalc(); //多态 加法
    calculor->setOperators(1,2);
    int tr=calculor->retValue();
    cout<< tr <<endl;

    calculor=new SubCalc;//多态 减法
    calculor->setOperators(1,2);
    tr=calculor->retValue();

    cout<< tr <<endl;
}