设计模式-策略模式

策略模式（Strategy）：它定义了算法家族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化，不会影响到使用算法的客户。

比如：超市会进行普通收费，打折，满减等活动，并且这些算法会经常变化。
UML：

与工厂模式不同之处在于：工厂与每个子类关联，并生成子类的实例。客户端需要知道这些具体的子类和工厂类。
而策略模式直接与抽象类关联，客户端通过固定的接口获得结果，只需要知道管理类即可。

//收费抽象类
class CashSuper {
public:
    virtual double acceptCash(double money) = 0;
};
//普通收费类
class CashNomal :public CashSuper {
public:
    double acceptCash(double money)
    {
        return money;
    }
};
//打折收费类
class CashReBate :public CashSuper {
private:
    double m_rebate;
public:
    CashReBate(double Rebate) :m_rebate(Rebate) {}
    double acceptCash(double money)
    {
        return money*m_rebate;
    }
};
//满减收费类
class CashReturn :public CashSuper {
private:
    double m_money;
    double m_return;
public:
    CashReturn(double Money, double Return) :m_money(Money), m_return(Return) {}
    double acceptCash(double money)
    {
        double res = money;
        if (money >= m_money)
            res = money - (money/m_money)*m_return;
        return res;
    }
};
enum TYPE { Nomal, Rebate, Return };
//收费管理类（一般使用简单工厂方法，将switch从客户端转移过来）
class CashContext {
private:
    CashSuper *cs;
public:
    CashContext(TYPE type)
    {
        switch (type)
        {
        case Nomal:
            cs = new CashNomal();
            break;
        case Rebate:
            cs = new CashReBate(0.8);
            break;
        case Return:
            cs = new CashReturn(300, 100);
            break;
        }
    }
    double GetResult(double money)
    {
        return cs->acceptCash(money);
    }
};

int main()
{
    CashContext *super1 = new CashContext(Nomal);
    cout << super1->GetResult(100) << endl;
    CashContext *super2 = new CashContext(Rebate);
    cout << super2->GetResult(100) << endl;
    CashContext *super3 = new CashContext(Return);
    cout << super3->GetResult(300) << endl;
    system("pause");
    return 0;
}