设计模式C++版：第一式策略模式

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

具体示例如下：

class CashSuper                    //抽象
{
public:
  virtual double acceptCash(double money) = 0;
  virtual ~CashSuper(){}
};


class CashNormal :public CashSuper //正常收费
{
public:

  double acceptCash(double money)
{
return money;
}
};


class CashRebate : public CashSuper   //打折
{
public:
double acceptCash(double money)
{
return moneyRebate * money;
}

CashRebate(double rebate) :moneyRebate(rebate) { }
private:
double moneyRebate = 1;       //c++11可以如此使用
};


class CashReturn : public CashSuper //返还
{
public:
CashReturn(double condition, double returnmoney)
{
this->moneycondition = condition;
this->moneyreturn = returnmoney;
}

double acceptCash(double money)
{
double result = money;
if (money >=moneycondition)
{
return  result - (money / moneycondition)*moneyreturn;
}
return result;
}


private:
double moneycondition = 0.0;
double moneyreturn = 0.0;
};

enum STRATEGY            //收费模式（策略模式）
{
ZCSF = 1,
DZSF = 2,
MFSF = 3
};


class Contex //策略上下文
{
public:
ouble getresult(double money)
{
return m_cash->acceptCash(money);
}


Contex(STRATEGY strategy)
{
switch (strategy)
{
case ZCSF:
m_cash = new CashNormal;
break;
case DZSF:
m_cash = new CashRebate(0.8);
break;
case MFSF:
m_cash = new CashReturn(300, 100);
break;
default:
m_cash = new CashNormal;
break;
}
}
private:
CashSuper *m_cash;
};

int main(int argc, char** argv)
{
Contex *context = new Contex(MFSF);
double total = 800;
total = context->getresult(total);
std::cout << total << std::endl;
delete context;
return 0;
}

代码写到这里是不是感觉和简单工厂模式很像。确实很类似。但相对于简单工厂它的封装性更好，耦合性更低。因为在客户端我们只要需要识别一个context类就可以了。