设计模式(行为型)命令模式， 观察者模式

1、命令模式

 命令模式（Command Pattern）是一种数据驱动的设计模式，它属于行为型模式。请求以命令的形式包裹在对象中，并传给调用对象。调用对象寻找可以处理该命令的合适的对象，并把该命令传给相应的对象，该对象执行命令。

1.1 实例

 假设客户向服务器进行多次的请求，实现和服务器之间解耦，用容器保存请求。

代码步骤：
1、先封装一个类（HandleClientProtocol），类中是client的命令
2、封装一个抽象类（AbstractCommand）
3、把client中的每个命令封装成一个类，同时继承抽象类
4、server方面，Server中维护一个队列，用于接收命令和执行命令

class  HandleClientProtocol {
public:
	//增加金币
	void AddMoney()
	{
		cout << "给玩家增加金币"<<endl;
	}
	//增加钻石
	void AddDiamond()
	{
		cout << "给玩家增加钻石" << endl;
	}
	//升级
	void Update()
	{
		cout << "给玩家升级" << endl;
	}
};
//协议命令接口
class AbstractCommand{
public:
	virtual void handle() = 0;
};

//增加金币请求
class AddMoneyCommand :public AbstractCommand{
public:
	AddMoneyCommand(HandleClientProtocol* Protocol)
	{
		pProtocol = Protocol;
	}
	virtual void handle()
	{
		this->pProtocol->AddMoney();
	}
public:
	HandleClientProtocol* pProtocol;
};

//增加钻石请求
class AddDiamondCommand :public AbstractCommand {
public:
	AddDiamondCommand(HandleClientProtocol* Protocol)
	{
		pProtocol = Protocol;
	}
	virtual void handle()
	{
		this->pProtocol->AddDiamond();
	}
public:
	HandleClientProtocol* pProtocol;
};

//增加升级
class AddUpdateCommand :public AbstractCommand {
public:
	AddUpdateCommand(HandleClientProtocol* Protocol)
	{
		pProtocol = Protocol;
	}
	virtual void handle()
	{
		this->pProtocol->Update();
	}
public:
	HandleClientProtocol* pProtocol;
};

//服务器程序  命令不一定及时处理，将请求加到队列
//函数不能增加到队列中，可以是对象
class Server {
public:
	void addRequest(AbstractCommand* command)
	{
		mCommands.push(command);
	}
	void startHandle()
	{
		while (!mCommands.empty()) {
			Sleep(1000);
			AbstractCommand* command = mCommands.front();
			command->handle();
			mCommands.pop();
		}
	}
public:
	queue<AbstractCommand*> mCommands;
};
void test()
{
	HandleClientProtocol* protocol = new HandleClientProtocol;
	//增加金币请求
	AbstractCommand* addmoney = new AddMoneyCommand(protocol);
	//增加钻石请求
	AbstractCommand* adddiamond = new AddDiamondCommand(protocol);
	//增加升级请求
	AbstractCommand* addupdate= new AddUpdateCommand(protocol);

	Server* svr = new Server;
	svr->addRequest(addmoney);
	svr->addRequest(adddiamond);
	svr->addRequest(addupdate);

	svr->startHandle();

}
int main()
{
	test();
	return 0;
}

2、观察者模式

 观察者模式主要是是定义对象间的一种一对多（变化）的依赖关系，以便当一个对象(Subject)的状态发生改变时，所有依赖于它的对象都得到通知并自动更新。
 而我们设计程序有两个基本原则，开闭原则和依赖倒置原则，开闭原则在于对源代码的更改是不建议的，而对原始程序进行模块添加是建议的（策略模式）。而依赖倒置原则是要求具体的类要依赖于抽象类，借助于抽象类的接口，实现具体的类或功能。
 现在有大量的关于设计模式的书，讲的都挺不错，但基本上都是使用java语言的，是使用c++语言的很少，这里我们使用c++语言来实现。我们的设计模型：首先我们假设有多个hero攻击boss，当boos被消灭的时候会通知hero，让停止攻击进入等待状态。

这里，boosA就是被观察者，而heroA,heroB,heroC 是观察者。

2.2 实例

 对于观察者，被观察者都要将他们抽象出具体的接口，然后再底层进行实现。而且再被观察者的类中，需要添加一个链表或者队列，里面是需要通知的观察者，并且各个观察者的地位是平等的。

#include<iostream>
#include<list>
using namespace std;
///观察者抽象方法
class AbstractHero {
public:
	virtual void Update() = 0;
};

///具体的观察者
class HeroA :public AbstractHero {
public:
	HeroA() {
		cout << "英雄A正在打boss..." << endl;
	}
	virtual void Update() {
		cout << "英雄A停止打boss，待机..." << endl;
	}
};
class HeroB :public AbstractHero {
public:
	HeroB() {
		cout << "英雄B正在打boss..." << endl;
	}
	virtual void Update() {
		cout << "英雄B停止打boss，待机..." << endl;
	}
};
class HeroC :public AbstractHero {
public:
	HeroC() {
		cout << "英雄C正在打boss..." << endl;
	}
	virtual void Update() {
		cout << "英雄A停止打boss，待机..." << endl;
	}
};
///被观察者抽象方法
class AbstractBoss {
public:
	//添加观察者
	virtual void addHero(AbstractHero* hero) = 0;
	//删除观察者
	virtual void deleteHero(AbstractHero* hero) = 0;
	//通知观察者
	virtual void notify() = 0;
};
//具体地被观察者 BOSS
class BossA :public AbstractBoss {
public:
	//添加观察者
	virtual void addHero(AbstractHero* hero) {
		pHeroList.push_back(hero);
	}
	//删除观察者
	virtual void deleteHero(AbstractHero* hero) {
		pHeroList.remove(hero);
	}
	//通知观察者
	virtual void notify() {
		for (auto e : pHeroList)
		{
			e->Update();
		}
	}
private:
	list<AbstractHero*> pHeroList;
};

void test() {
	//创建观察者
	AbstractHero* heroA = new HeroA;
	AbstractHero* heroB = new HeroB;
	AbstractHero* heroC = new HeroC;
	//创建观察目标
	AbstractBoss* boosA = new BossA;
	boosA->addHero(heroA);
	boosA->addHero(heroB);
	boosA->addHero(heroC);
	cout << "heroC阵亡..." << endl;
	boosA->deleteHero(heroC);
	cout << "boosA消灭，通知..." << endl;
	boosA->notify();
}
int main()
{
	test();
}