策略模式

它定义了一系列的算法，并将每个算法封装起来，而且使他们还可以相互替换。策略模式让算法的变化不会影响到使用算法的客户。

优点：

　　1）简化了单元测试，因为每个算法都有自己的类，可以通过自己的接口单独测试。

　　2）避免程序中使用多重条件转移语句，使系统更灵活，并易于扩展。

　　3）遵守大部分GRASP原则和常用设计原则，高内聚、低耦合。

缺点：

　　1）因为每个具体策略类都会产生一个新类，所以会增加系统需要维护类的数量。

　　2）在基本的策略模式中，选择所用具体实现的职责由客户端对象承担，并转给策略模式的Context对象。

进一步优化可以将策略模式与简单工厂模式相结合，选择所用具体实现的职责也可以由Context对象承担，这就最大化的减轻了客户端的职责。

结合策略模式与简单工厂模式实现的简单收银系统代码：

Strategy.h:

#include<iostream>
#include<string>
#include<memory>
using namespace std;

//strategy抽象类，用作接口
class Strategy
{
public:
    virtual double GetResult(double money) = 0;
    virtual ~Strategy()
    {
        cout<<" in the destructor of Strategy"<<endl;
    }
};
//正常结算方式
class CashNormal : public Strategy
{
    double GetResult(double money)
    {
        return money;
    }
    ~CashNormal()
    {
        cout<<" in the destructor of CashNormal"<<endl;
    }
};    
//打折
class CashRebate : public Strategy
{
private:
    double moneyRebate;  //折扣率
public:
    //构造函数
    CashRebate(double rebate)
    {
        moneyRebate = rebate;
    }

    double GetRebate()
    {
        return moneyRebate;
    }
    void SetRebate(double rebate)
    {
        moneyRebate = rebate;
    }

    double GetResult(double money)
    {
        return money * moneyRebate;
    }
};
//返现
class CashReturn : public Strategy
{
    //返现的条件与方式
private:
    double moneyCondition;
    double moneyReturn;
public:
    //构造函数
    CashReturn(double condition, double re)
    {
        moneyCondition = condition;
        moneyReturn = re;
    }

    double GetCondition()
    {
        return moneyCondition;
    }
    void SetCondition(double condition)
    {
        moneyCondition = condition;
    }
    double GetReturn()
    {
        return moneyReturn;
    }
    void SetReturn(double re)
    {
        moneyReturn = re; 
    }

    double GetResult(double money)
    {
        if(money >= moneyCondition)
        {
            money = money - (int)(money / moneyCondition) * moneyReturn;
        }
        return money;
    }
};

//现金收费工厂类
class CashFactory
{
public:
    static Strategy* createGetResult(int type)
    {
        Strategy* cs;
        switch(type)
        {
        case 0:
            cs = new CashNormal();
            break;
        case 1:
            cs = new CashRebate(0.8);
            break;
        case 2:
            cs = new CashReturn(300,100);
            break;
        default:
            break;
        }
        return cs;
    }
};

//CashContext类   策略模式与简单工厂模式相结合
class CashContext
{
private:
    Strategy* cs;
public:
    CashContext(int type)
    {
        bool loop = true;
        while(loop){
        switch (type)
        {
        case 0:
            cs =new CashNormal();
            loop = false;
            break;
        case 1:
            cs = new CashRebate(0.8);
            loop = false;
            break;
        case 2:
            cs = new CashReturn(300,100);
            loop = false;
            break;
        default:
            cout<<"输入有误! 请重新输入!"<<endl;
            cin>>type;
            break;
        }
        }
    }

    double GetResult(double money)
    {
        return cs->GetResult(money);
    }
};

Strategy.cpp:

#include "Strategy.h"
void main(int argc, char *argv)
{
    int type = 0;
    double total = 0;
    cout<<"选择收费方式:"<<endl
        <<"0:正常方式"<<endl
        <<"1:打折方式"<<endl
        <<"2:返现方式"<<endl;
    cin >> type;
    /*
    CashFactory cfactory;
    Strategy *pay = cfactory.createGetResult(type);
    cout<<"输入总的消费金额:";
    cin >> total;
    cout<<"应收金额为:"<<pay->GetResult(total)<<endl;
    */
    CashContext cs(type);
    cout<<"输入总的消费金额:";
    cin >> total;
    cout<<"应收金额为:"<<cs.GetResult(total)<<endl;
}