策略模式实现

    学了C++基本的语法都知道继承可以让子类拥有更多的功能，除了继承还有组合，委托，也能让一个类的功能增加。设计模式，这个设计是设计继承，组合，委托，之间相互叠加的方式，让其符合业务需求。

策略模式是继承和委托的结合，它可以像是创建性模式，因为它像工厂一样创建对象；它也像行为型模式，因为这些创建的对象最终要完成动作（调用函数）。

   看到这，我认为你已经看了上节的观察者模式，那么这个对你来说很容易理解，因为太像了，都是对委托的运用，不同的是主题要通知每个观察者，而策略模式，会根据用户的需求，选择调用委托的一个对象的函数，来完成动作。

    这些代码都是在学习这些的过程中码的。。。。。

上代码，亲测有效！

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

//策略模式：一个类A中包含一个基类对象，这个基类有一个方法
//在子类中以不同方式实现，因此类A可以引用到这些方法。

enum TYPE
{
A, B, C
};

//基类《九阴真经》
class UpBook
{
public: 
	virtual void Throw() = 0;
};

//子类A
class BookA : public UpBook
{
public:
	void Throw()
	{
		cout << "skillA" << endl;
	}
};

//子类B
class BookB : public UpBook
{
public:
	void Throw()
	{
		cout << "skillB" << endl;
	}
};

//子类C
class BookC : public UpBook
{
public:
	void Throw()
	{
		cout << "skillC" << endl;
	}
};

//杨过
class SingleArm
{
public:
	void Read(TYPE type)
	{
		if (type == TYPE::A)
		{
			if (bookA == NULL)
			{
				bookA = new BookA;
			}
			upBook = bookA;
		}
		if (type == TYPE::B)
		{
			if (bookB == NULL)
			{
				bookB = new BookB;
			}
			upBook = bookB;
		}
		if (type == TYPE::C)
		{
			if (bookC == NULL)
			{
				bookC = new BookC;
			}
			upBook = bookC;
		}
	}
	~SingleArm()
	{
		if (bookA != NULL)
		{
			delete bookA;
		}
		if (bookB != NULL)
		{
			delete bookB;
		}
		if (bookC != NULL)
		{
			delete bookC;
		}
		if (upBook != NULL)
		{
			delete upBook;
		}
	}
	UpBook* upBook = NULL;//纯虚函数不允许实例化
private:
	BookA* bookA = NULL;
	BookB* bookB = NULL;
	BookC* bookC = NULL;
};


int main(void)
{
	//定义英雄
	SingleArm* singleArm = new SingleArm;
	//看不同的书后可以使用不同的技能
	//策略模式
	singleArm->Read(TYPE::A);//看书
	singleArm->upBook->Throw();//使用书中技能
	singleArm->Read(TYPE::B);
	//upBook里的实际值和Throw()
	//都不是抽象类UpBook的对象和函数实现
	singleArm->upBook->Throw();
	singleArm->Read(TYPE::C);
	singleArm->upBook->Throw();
	system("pause");
	return 0;
}