2 策略模式（2）

#include <iostream>
#include <string>

 using std::string;
using std::cout;
using std::endl;
using std::cin;

//现金收费抽象类
class CashSuper
{
public:
    virtual double AcceptCash(double money) = 0;
};

//正常收费子类
class CashNormal : public CashSuper
{
public:
    double AcceptCash(double money)
    {
        return money;
    }
};

//打折收费子类
class CashRebate : public CashSuper
{
public:
    CashRebate(double moneyRebate)
    {
        this->moneyRebate = moneyRebate;
    }
    double AcceptCash(double money)
    {
        return money * moneyRebate;
    }
private:
    double moneyRebate;
};

//返回收费子类
class CashReturn : public CashSuper
{
public:
    CashReturn(double moneyCondition, double moneyReturn)
    {
        this->moneyCondition = moneyCondition;
        this->moneyReturn = moneyReturn;
    }
    double AcceptCash(double money)
    {
        if(money > moneyCondition)
        {
            return money - (int) money / (int)moneyCondition * moneyReturn;
        }
        else
        {
            return money;
        }
    }
private:
    double moneyCondition;
    double moneyReturn;
};

//如果使用工厂模式
class CashFactory
{
public:
    static CashSuper* CreateCashAccept(string type)
    {
        CashSuper* cs = NULL;
        if(type == "正常收费")
        {
            cs = new CashNormal();
        }
        else if(type == "满300送100")
        {
            cs = new CashReturn(300, 100);
        }
        else if(type == "打8折")
        {
            cs = new CashRebate(0.8);
        }
        else
        {
            cs = new CashNormal();
        }
        return cs;

    }
};

//如果使用策略模式
class CashContext
{
public:
    //通过构造方法传入具体的收费策略
    CashContext(CashSuper* csuper)
    {
        this->cs = csuper; 
    }
    //策略模式与工厂模式结合
    //参数不是具体的策略对象，而是一个字符串，表示收费类型
    CashContext(string type)
    {
        if(type == "正常收费")
        {
            cs = new CashNormal();
        }
        else if(type == "满300送100")
        {
            cs = new CashReturn(300, 100);
        }
        else if(type == "打8折")
        {
            cs = new CashRebate(0.8);
        }
        else
        {
            cs = new CashNormal();
        }
    }
    double GetResult(double money)
    {
        return cs->AcceptCash(money);
    }
private:
    CashSuper* cs;
};

int main()
{
    //如果使用工厂模式
    CashSuper* cs = CashFactory::CreateCashAccept("正常收费");
    cout<<cs->AcceptCash(500)<<endl;

    //如果使用策略模式
    CashContext* cc = NULL;

    string type;
    cin>>type;
    if(type == "正常收费")
    {
        cc = new CashContext(new CashNormal());
    }
    else if(type == "满300送100")
    {
        cc = new CashContext(new CashReturn(300, 100));
    }
    else if(type == "打8折")
    {
        cc = new CashContext(new CashRebate(0.8));
    }

    cout<<cc->GetResult(500)<<endl;

    //如果使用策略模式和工厂模式结合
    cc = new CashContext(type);
    cout<<cc->GetResult()<<endl;

    //“简单工厂模式我需要让客户端认识两个类，CashSuper和CashFactory，而策略模式与简单工厂模式结合的用法，客户端就只需要认识一个雷CashContext就可以了。耦合更加降低”
    //“说的没错，我们在客户端实例化的是CashContext的对象，调用的是CashContext的方法GetResult，这使得具体的收费算法彻底地与客户端分离。连算法的父类CashSuper都不让客户端认识了。”
 
    return 0;
}