设计模式(2)---策略模式

 　　个人对于策略模式的理解是在于可替换性，不同的策略代表不同的算法和策略，他们之间应该是拥有共同的对外的接口，在不同的场景下使用不同的策略，除了替换策略部分，其余的代码都不需要做任何更改。这样就具有高复用性，下面代码中多个类都是从Cash继承，不同的子类就是不同的策略。

#include <memory>
#include <string>
#include <iostream>

using namespace std;

class Cash
{
public:
    virtual double acceptCash(double cash) = 0;
};

class NormalCash : public Cash
{
public:
    double acceptCash(double cash)
    {
        cout << "normal cash:" << cash << endl;
        return cash;
    }
};

class RebateCash : public Cash
{
public:
    RebateCash(double rebate = 1.0) : rebate_(rebate)
    {}
    double acceptCash(double cash)
    {
        cout << "rebate cash:" << cash << endl;
        return cash*rebate_;
    }
private:
    double rebate_;
};
class ReturnCash : public Cash
{
public:
    ReturnCash(double moneyCondition, double moneyReturn) :moneyCondition_(moneyCondition),moneyReturn_(moneyReturn)
    {}
    double acceptCash(double cash)
    {
        cout << "return cash:" << cash << endl;
        int returnNum = static_cast<int>(cash / moneyCondition_);
        return cash - returnNum * moneyReturn_;
    }
private:
    double moneyCondition_;
    double moneyReturn_;
};
enum CASH_TYPE
{
    NORMAL_CASH,
    REBATE_CASH,
    RETURN_CASH,

    CASH_BUTTON
};

shared_ptr<Cash> cashFactory(CASH_TYPE cashType  = NORMAL_CASH, double parameterA = 0, double parameterB = 0)
{
    switch (cashType)
    {
    case NORMAL_CASH:
        return make_shared<NormalCash>();
    case REBATE_CASH:
        return make_shared<RebateCash>(parameterA);
    case RETURN_CASH:
        return make_shared<ReturnCash>(parameterA, parameterB);
    default:
        cout << "Can not distinguish the cash_type" << endl;
        return nullptr;
    }
}

class CashContext
{
public:
    CashContext(shared_ptr<Cash> cashProcesser) :cashNum_(0), discountCashSum_(0), originalCashSum_(0),
        cashProcesser_(cashProcesser)
    {
    }
    double acceptCash(double cash)
    {
        double price;    

        price = cashProcesser_->acceptCash(cash);

        discountCashSum_ += price;
        originalCashSum_ += cash;
        cashNum_ += 1;

        return price;
    }
    shared_ptr<Cash> setCashProcesser(shared_ptr<Cash> newProcesser)
    {
        auto oldProcesser = cashProcesser_;
        cashProcesser_ = newProcesser;
        return oldProcesser;
    }
private:
    int cashNum_;
    double discountCashSum_;
    double originalCashSum_;
    shared_ptr<Cash> cashProcesser_;
};


int main()
{
    shared_ptr<Cash> normalCashProcesser = cashFactory(NORMAL_CASH);
    shared_ptr<Cash> rebateCashProcesser = cashFactory(REBATE_CASH, 0.8);
    shared_ptr<Cash> returnCashProcesser = cashFactory(RETURN_CASH, 300 ,50);

    CashContext cashContext(normalCashProcesser);
    cashContext.acceptCash(30);
    
    cashContext.setCashProcesser(rebateCashProcesser);
    cashContext.acceptCash(30);

    cashContext.setCashProcesser(returnCashProcesser);
    cashContext.acceptCash(30);

    return 0;
}