策略模式--对象行为模式

意图：定义一系列的算法，把它们一个个封装起来，并且使它们可互相替换。使算法可独立于使用它的客户而变化。

适用性：
许多相关的类仅仅是行为有异。“策略”提供了一种用多个行为中的一个来配置以各类的方法。
需要使用一个算法的不同变体。
算法使用客户不应该知道的数据，可使用策略模式以避免暴露复杂的，与算法相关的数据机构。
一个类定义了多种行为，并且这些行为在这个类的操作中以多个条件语句的形式出现。将相关的条件分支移入它们各自的Strategy类中以代替这些条件语句。
结构：

参与者：
Strategy：定义所有支持的算法的公共接口。Context使用这个接口来调用某ConcreteStrategy定义的算法。
ConcreteStrategy：具体策略。以Strategy接口实现某具体算法。
Context：上下文，用一个ConcreteStrategy对象来配置；维护一个对Strategy对象的引用；可定义一个接口来让Stategy来访问它的数据。
协作：
Strategy和Context相互作用以实现选定的算法。当算法被调用时，Context可以将该算法所需要的所有数据都传递给该Strategy，或者Context将自身作为一个参数传递给Strategy操作。
Context将它的客户的请求转发给它的Strategy。客户通常创建并传递一个ConcreteStrategy对象给该Context；这样，客户仅余Context交互。通常有一系列的ConcreteStrategy类可供客户从中选择。
效果：

优点：

1 相关算法系列。Strategy类层次为Context定义了一系列可供重用的算法或行为。继承有助于吸取出这些算法的公共功能。
2 一个替代继承的方法。不用直接继承Context类，用子类来实现不同的行为。而将这些算法独立出来，可以单独变化。
3 消除了一些条件语句。将不同的选择行为放在一个类中，将行为封装到了一个个Strategy类
4 实现的选择。提供相同行为的不同实现。

缺点：

5 客户必须了解不同的Strategy。本模式一般是在客户端选择一个合适的Strategy，所以客户端就应知道这些之间有什么不同。所以这些会暴露在客户面前。
6 Strategy和Context之间的通信开销。

   strategy有时需要使用context的数据，所以需要将数据传送给自己保存的strategy，一般解决方法

   （1）让Context将数据放在参数中传递给strategy，这使context与strategy解偶，但是对于一些具体策略类，可能有些参数并不需要，即传递了多余的参数

   （2）将Context自身作为一个参数传递给strategy,然后strategy中再显示的用该参数获取context的数据（getValue）;

            或Strategy存储一个对它的引用，则不需要传递参数，但是在初始化策略类时初始化strategy的引用。

    书中还有一种方法，在c++中可以利用模板机制用一个Strategy配置一个类，即用Strategy作为一个模板参数传递给Context.

    条件：可以在编译时选择Strategy，不需要运行时改变，使用模板不需要Strategy定义接口的抽象类。

7 增加了对象的数目。可以结合向原模式来改进，但是现在又忘了，回来再改把～～

实现：
定义Strategy和Context接口
接口必须使得ConcreteStrategy能够有效地访问它所需要的Context中的任何数据。
方法在上面已经阐述，即通信开销中。

代码：

//策略模式：定义一系列的算法，把它们一个个封装起来，并使
//它们可相互替换。使得算法可独立于使用它的客户而变化。

#include <iostream>
#include <cmath>
using namespace std;

//策略抽象类
class CashSuper
{
public:
	virtual double acceptCash(double money = 0.0) = 0; 
};

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

//打折收费子类
class CashRebate : public CashSuper
{
public:
	//构造函数提供打折力度
	CashRebate(double moneyRebate = 1.0) : _moneyRebate(moneyRebate)
	{
	
	}

	double acceptCash(double money)
	{
		return money * _moneyRebate;
	}
private:
	double _moneyRebate; 
};

//返利收费子类
class CashReturn : public CashSuper
{
public:
	//构造函数提供满XX返XX
	CashReturn(double moneyCondition = 0.0, double moneyReturn = 0.0)
		: _moneyCondition(moneyCondition), _moneyReturn(moneyReturn)
	{
	}

	double acceptCash(double money)
	{
		double result = money;
		if (money >= _moneyCondition)
			result = money - floor(money/_moneyCondition) * _moneyReturn;
		return result;
	}
private:
	double _moneyCondition;
	double _moneyReturn;
};

//上下文
class CashContext
{
public:
	//通过构造方法传入具体的收费策略和钱的总数
	CashContext(CashSuper* csuper, double money) : cs(csuper), _money(money)
	{
		cs = csuper;
	}

	~CashContext()
	{
		delete cs;
	}

	double GetResult()
	{
		//将数据成员通过参数传给策略类
		return cs->acceptCash(_money);
	}
private:
	//保持一个策略类的指针，来调用相应的策略
	CashSuper* cs;
	double _money;
};

#include "strategy.h"

int main()
{
	CashContext cc(new CashNormal, 300);
	cout << cc.GetResult() << endl;

	CashContext cc1(new CashRebate(0.7), 300);
	cout << cc1.GetResult() << endl;

	CashContext cc2(new CashReturn(300, 100), 300);
	cout << cc2.GetResult() << endl;

	system("pause");
	return 0;
}