策略模式（Strategy）:
策略模式定义了算法家族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化，不会影响到使用算法的客户。
Strategy类，定义所有支持的算法的公共接口：
//抽象算法类
class Strategy
{
//算法函数
public:
virtual void AlgorithmInterface()=0;
};
ConcreteStrategy,封装了具体的算法或行为，继承于Strategy
class ConcreteStrategyA :virtual publicStrategy
{
public:
//算法A实现
void AlgorithmInterface()
{
//算法A
}
}
class ConcreteStrategyB :virtual publicStrategy
{
public:
//算法B实现
void AlgorithmInterface()
{
//算法B
}
}
class ConcreteStrategyC :virtual publicStrategy
{
public:
//算法C实现
void AlgorithmInterface()
{
//算法C
}
}
Context ,用一个ConcreteStrategy来配置，维护一个对Strategy对象指针。
class Context
{
public:
Context(Strategystrategy)
{
This->strategy=strategy;
}
voidcontextInterface()
{
Strategy->AlgoritmInterface();
}
private:
Strategy * strategy;
};
客户端代码：
int main()
{
Context *context;
context=newContext(new ConcreteStrategyA());
context->ContextInterface();
context=new Context(new ConcreteStrategyB());
context->ContextInterface();
context=newContext(new ConcreteStrategyC());
context->ContextInterface();
delete context;
//由于实例化不同的策略，所以最终在调用context->ContextInterface();时，所获得的结果就//不尽相同
}
策略模式实现-商场收银系统
#include<iostream>
#include<string>
usingnamespace std;
classCashSuper
{
public:
virtual double acceptCash(doublemoney)=0;
};
classCashNormal : virtual public CashSuper
{
public:
double acceptCash(double money)
{
return money;
}
};
classCashRebate : virtual public CashSuper
{
public:
CashRebate(double MoneyRebate)
{
this->MoneyRebate=MoneyRebate;
}
double acceptCash(double money)
{
return money*MoneyRebate;
}
private:
double MoneyRebate;
};
classCashReturn : virtual public CashSuper
{
public:
CashReturn(double moneyCondition,doublemoneyReturn):moneyCondition(moneyCondition),moneyReturn(moneyReturn){}
double acceptCash(double money)
{
double result=money;
if(money>=moneyCondition)
{
result =money-(money/moneyCondition)*moneyReturn;
}
return result;
}
private:
double moneyCondition;
double moneyReturn;
};
classCashContext
{
public:
CashContext(CashSuper * pcs)
{
this->pcs=pcs;
}
double getResult(double money)
{
return pcs->acceptCash(money);
}
private:
CashSuper * pcs;
};
intmain()
{
cout<<"请选择付款类型-1:正常付款，2:满300返100,3:打8折："<<endl;
int index;
cin>>index;
CashContext *pcc=NULL;
switch(index)
{
case 1:
pcc=new CashContext(newCashNormal());
break;
case 2:
pcc=new CashContext(newCashReturn(300,100));
break;
case 3:
pcc=new CashContext(newCashRebate(0.8));
break;
default:
break;
}
double totalPrices=NULL;
double txtPrices=NULL;
double txtNum=NULL;
cout<<"请输入商品的单价和数量："<<endl;
cin>>txtPrices>>txtNum;
totalPrices=pcc->getResult(txtPrices*txtNum);
cout<<"商品单价："<<txtPrices<<","<<"商品数量："<<txtNum<<","<<"合计："<<totalPrices<<endl;
delete pcc;
return 0;
}
但是由于实例化对象在main函数中进行了，这使得业务逻辑和界面逻辑不能分开。
我们应该进一步的改进该程序，使得实例化对象脱离界面逻辑，这样我们就应该使用策略模式和简单工厂模式结合起来。
我们只要在CashContext中实现对象的实例化就可以了
CashContext类的改进：
classCashContext
{
public:
CashContext(int Index)
{
switch(Idex)
{
case 1:
pcs=new CashNormal();
break;
case 2:
pcs=new CashReturn(300,100);
break;
case 3:
pcs=new CashRebate(0.8);
break;
default：
break;
}
}
double getResult(double money)
{
return pcs->acceptCash(money);
}
private:
CashSuper * pcs;
};
原来简单工厂模式并非只有建一个工厂类的做法，还可以这样做，此时比刚才的策略模式的写法要清楚多了，main函数的代码简单明了。
策略模式解析：
策略模式是一种定义一系列算法的方法，从所有这些算法完成的都是相同的工作，只是实现不同，它可以相同的方式调用所有算法，减少了各种算法类与使用算法类之间的耦合。
策略模式的Strategy类层次为Context定义了一系列的可供重用的算法和行为。继承有助于析取出这些算法中的公共功能。
另外一个策略模式的优点是简化了单元测试，因为每个算法都有自己的类，可以通过自己的接口单独测试。
策略模式就是用来封装算法的，但在实践中，我们发现可以用它封装几乎任何类型的规则，只要在分析过程中听到需要在不同时间应用不同的业务规则，就可以考虑使用策略模式处理这种变化的可能性。