概念：

       策略模式定义了一系列的算法，分别封装起来，让它们之间能够相互替换。

此模式让算法的变化，不会影响到使用算法的客户。策略，实质上指的是算法。

       样例：

       一个鲜活简单的样例总能让人轻松地理解晦涩的概念。

我们来看看一个关于汽车价格的策略模式。

       我们知道。汽车的品牌和质量。决定了它的价格。

就像宝马（BMW）。法拉利（Ferrali）和奔驰（Benz）三辆汽车，它们的价格肯定是不一样的。那假设想要知道它的价格的话。能够询问销售人员等等。可是在计算机里，我们可不能直接问销售人员啊！

       对于它们来说。尽管各自价格不同。是不同的算法。可是获取价格却是一种公共操作（策略模式要求的就是要封装变化的算法）。于是。能够创建一个抽象父类汽车类（Car），声明一个获取价格virtual GetPrice函数的接口。

然后创建三个子类：BMW，Ferrali和Benz，分别继承于Car。通过继承关系，每一个子类能够改写父类的GetPrice函数，然后在client中通过调用不同的汽车子类算法来获取子类汽车价格。

       总结一下：

       1、我们把父类Car当成是抽象策略类，提供了一个获取价格的GetPrice接口；

       2、每种包括获取价格GetPrice的汽车类为详细策略类（每种牌子的车价格不一致，导致不同计算算法）。要重写父类Car的GetPrice函数；

       3、建立一个环境上下文类PriceContext，维护一个对父类Car对象（指针对象才干实现多态）的引用。最后给client调用详细的策略类对象。

     UML图：

    代码：

#include <iostream>
using namespace std;

class Car
{
public:
	float m_fPrice;
	
public:
	virtual float GetPrice()
	{
		return m_fPrice*1;
	}
};

class BMW:public Car
{
public:
	float GetPrice()
	{
		return m_fPrice*3;
	}
};

class Ferrali:public Car
{
public:
	float GetPrice()
	{
		return m_fPrice*11;
	}
};

class Benz:public Car
{
public:
	float GetPrice()
	{
		return m_fPrice*6;
	}
};

class PriceContext
{
public:
	int m_iFlag;

private:
	Car* m_cCar;

public:
	PriceContext(Car* cCar):m_cCar(cCar)
	{
		//this->m_cCar = cCar;
	}

	float GetPriceContext()
	{
		m_cCar->m_fPrice = 10000;
		return(m_cCar->GetPrice());
	}
};

int main()
{
	float fPrice=0.0;
	int iTag=0;

 	cout<<"----策略模式開始----"<<endl;
 	cout<<"BMW:1,Ferrali:2,Benz:3"<<endl;
 	cout<<"请输入您想要查询的汽车价格：";
 	cin>>iTag;

	PriceContext* priceContext;

	switch (iTag)
	{
	case 1:
		priceContext = new PriceContext(new BMW);
		break;
	case 2:
		priceContext = new PriceContext(new Ferrali);
		break;
	case 3:
		priceContext = new PriceContext(new Benz);
		break;
	default:
		priceContext = new PriceContext(new Car);
		break;
	}

	fPrice = priceContext->GetPriceContext();

	delete priceContext;
	priceContext = NULL;
 	
 	cout<<"价格为："<<fPrice<<endl;
 	cout<<"----策略模式结束----"<<endl;
	
	return 1;
}

   策略模式和简单工厂模式相结合：

    简单工厂模式中。对象的动态创建推断放在了工厂类中。

而主要的策略模式client还是要进行算法推断和对象创建。

因此可模仿简单工厂，把算法的推断移到环境上下文类中，尽量降低client职责，降低耦合性。当中相对简单工厂模式来说，client中连基类都不出现，更加地隐藏算法的详细实现细节。

    代码：

class PriceContext
{
public:
	int m_iFlag;

private:
	Car* m_cCar;

public:
	PriceContext(int iFlag)  //构造中不再穿对象。传标识
	{
		switch (iFlag)
		{
		case 1:
			m_cCar = new BMW;
			break;
		case 2:
			m_cCar = new Ferrali;
			break;
		case 3:
			m_cCar = new Benz;
			break;
		default:
			m_cCar = new Car;
			break;
		}
	}

	float GetPriceContext()
	{
		m_cCar->m_fPrice = 10000;
		return(m_cCar->GetPrice());
	}
};

int main()
{
	float fPrice=0.0;
	int iTag=0;

 	cout<<"----策略模式開始----"<<endl;
 	cout<<"BMW:1,Ferrali:2,Benz:3"<<endl;
 	cout<<"请输入您想要查询的汽车价格：";
 	cin>>iTag;

	PriceContext* priceContext = new PriceContext(iTag);

	fPrice = priceContext->GetPriceContext();

	delete priceContext;
	priceContext = NULL;
 	
 	cout<<"价格为："<<fPrice<<endl;
 	cout<<"----策略模式结束----"<<endl;
	
	return 1;
}

    总结：

    1、策略模式定义了一系列的算法。从概念上看，全部算法完毕的都是同样的操作，仅仅是表现行为不同。通过同样的方式调用全部的算法（使用多态），降低了算法类与使用算法类之间的耦合。

    2、对客户隐藏详细策略(算法)的实现细节，彼此全然独立；

    3、策略模式简化了单元測试，每一个算法都有自己的类。能够通过自己的接口单独測试；

    4、client必须知道全部的策略类，并自行决定使用哪一个策略类。这就意味着client必须理解这些算法的差别，以便适时选择恰当的算法类。换言之，策略模式仅仅适用于client知道全部的算法或行为的情况。