命令模式和职责链模式

#include <Windows.h>
#include <vector>
#include <iostream>
using namespace std;

/*
命令模式和职责链模式
把这两个模式放在一起学习，因为觉得对比起来学习更有效果。
前者是多个命令交付给一个指定的处理者去处理
后者是将一个请求，按链式方式交付给多个执行者，找到其中适合执行的执行者去操作。

命令模式中主要是处理多个命令，通过中间人对命令的整理与修改，最后将命令名单发送给执行命令的执行者

职责链模式中将命令称之为请求，对请求的处理需要经过许多的执行者，这些执行者形成一个链。
通过链，使每一个执行者都有处理请求的机会，但只能处理有权限的请求，否则只能交给链中的下一个执行者。
*/

#define COMMAND_PATTERN 1
#define RESPON_CHAIN_PATTERN 0

/*命令模式：

组成：
(1)命令处理类，真正处理命令的类
(2)命令抽象类，实现命令的执行
(3)从命令抽象类派生的具体的实现命令类
(4)调用命令类，产生命令和执行命令的中间者

一个人去吃饭，找服务员点菜单，服务员记录菜单，并根据所点的菜单找到对应做此菜的师傅，通知师傅做饭。

过程：
(1)命令处理者，比如说点菜的命令，最后做菜的厨师就是处理者。
每个处理者可以完成多个功能，同样也可以有多个处理者例如做菜的师傅、做汤的师傅、做面点的师傅，可以通过一个处理者的抽象类构建。
(2)命令抽象类，命令无非就是指定处理的人，通知处理的人来处理。
在重载构造函数，通过参数传递处理者的对象指针。
添加调用命令执行接口，在派生类中调用不同的命令处理方法
(3)在命令派生类中，重载构造方法，实现调用命令执行接口方法
(4)执行者Invoker类，在现实中类似服务员的角色，记录点菜的命令菜单，并通知厨师去做菜。
可以讲命令保存到链表中，等待一起交付给处理者
可以实现命令的修改或者删除等处理
*/
#if COMMAND_PATTERN

class CommandHandler
{
public:
	void CmdActionA(){
		cout<<"CommandHandler CmdActionA"<<endl;
	}
	void CmdActionB(){
		cout<<"CommandHandler CmdActionB."<<endl;
	}
protected:
private:
};

class ICommandInf
{	
public:
	ICommandInf(){}
	ICommandInf(CommandHandler* pCommandHandler)
	{
		this->m_pReceiver = pCommandHandler;
	}

	virtual void ExeCommand() = 0;

protected:
	CommandHandler *m_pReceiver;
private:
};

class ConcreateCommandA : public ICommandInf{

public:
	ConcreateCommandA(CommandHandler* pCommandHandler){
		this->m_pReceiver = pCommandHandler;
	}
	virtual void ExeCommand(){
		m_pReceiver->CmdActionA();
	}

};

class ConcreateCommandB : public ICommandInf{

public:
	ConcreateCommandB(CommandHandler* pCommandHandler){
		this->m_pReceiver = pCommandHandler;
	}
	virtual void ExeCommand(){
		m_pReceiver->CmdActionB();

	}
};

class Invoker
{
public:

	void setCommand(ICommandInf* pCommand)
	{
		if (pCommand !=NULL)
		{
			m_pVecCmdList.push_back(pCommand);
		}
	}

	//modify
	void ModifyCmd(){};


	//notify
	void NotifyCommand()
	{
		for(int i=0;i<m_pVecCmdList.size();i++)
		{
			ICommandInf* pCmd = m_pVecCmdList.at(i);			
			pCmd->ExeCommand();
		}

		m_pVecCmdList.clear();
	}
protected:
private:
	vector<ICommandInf*>m_pVecCmdList;

};



void main()
{

	CommandHandler *pHandler = new CommandHandler();

	ICommandInf *pICA = new ConcreateCommandA(pHandler);
	ICommandInf *pICB = new ConcreateCommandB(pHandler);
	Invoker *pInvoker = new Invoker();

	pInvoker->setCommand(pICA);
	pInvoker->setCommand(pICB);
	pInvoker->setCommand(pICA);

	pInvoker->NotifyCommand();

	delete pHandler;pHandler = NULL;
	delete pICA;pICA = NULL;
	delete pICB;pICB = NULL;

	delete pInvoker;pInvoker = NULL;

}
#endif // _DEBUG



//
#if RESPON_CHAIN_PATTERN

/*职责链模式
定义：
使多个对象都有机会处理，从而避免请求的发送者和接受者之间的耦合关系。
将这个对象连成一个链，并沿着链传递该请求，知道有一个对象处理它为止。

组成：
(1)抽象处理者类
(2)具有不同权限的具体处理者类

过程：
(1)在抽象处理者类中实现setHandler方法，在派生类中调用此方法设置链表的指针
(2)在抽象类中添加处理请求的接口HandleRequest
(3)在具体处理者类中实现接口HandleRequest，分别处理各自权限内的请求。不在权限内则交给下一个处理者。
*/

class IHandler
{
public:
	IHandler(){m_pHandler = NULL;}

	virtual void setHandler(IHandler *pHandler){
		this->m_pHandler = pHandler;
		printf("(this)0x%x->m_pHandler:0x%x\n",this,this->m_pHandler);
	}
	virtual void HandleRequest(int nRequest) = 0;
protected:
	IHandler *m_pHandler;
private:
};

class Handler1 : public IHandler
{
public:
	virtual void HandleRequest(int nRequest)
	{
		printf("Handler1-HandleRequest :0x%x\n",m_pHandler);

		if (0<= nRequest && nRequest <= 10)
		{
			cout<<"Handler1 ..."<<nRequest<<endl;

		}else
		{
			if (m_pHandler != NULL)
			{
				m_pHandler->HandleRequest(nRequest);
			}else
			{

			}
		}
	}
protected:
private:
};


class Handler2 : public IHandler
{
public:
	virtual void HandleRequest(int nRequest)
	{
		printf("Handler2-HandleRequest :%d\n",m_pHandler);

		if (10< nRequest && nRequest <= 20)
		{
			cout<<"Handler2 ..."<<nRequest<<endl;

		}else
		{
			if (m_pHandler != NULL)
			{
			
				m_pHandler->HandleRequest(nRequest);
			}else
			{

			}
		}
	}
protected:
private:
};



class Handler3 : public IHandler
{
public:
	virtual void HandleRequest(int nRequest)
	{
		printf("Handler3-HandleRequest :%d\n",m_pHandler);

		if (20< nRequest && nRequest <= 30)
		{
			cout<<"Handler3 ..."<<nRequest<<endl;

		}else
		{
			if (m_pHandler == NULL)
			{
				cout<<"data has been over...no right to deal"<<endl;
			}
			
		}
	}
protected:
private:
};



void main()
{
	Handler1 *h1= new Handler1();
	Handler2 *h2= new Handler2();
	Handler3 *h3= new Handler3();

	printf("h1:0x%x\n",h1);
	printf("h2:0x%x\n",h2);
	printf("h3:0x%x\n\n",h3);

	h1->setHandler(h2);
	h2->setHandler(h3);


	

	int  nRequest[] = {2,15,22,300};

	for (int i=0;i<_countof(nRequest);i++)
	{
		h1->HandleRequest(nRequest[i]);
	}

	delete h1;h1 = NULL;
	delete h2;h2 = NULL;
	delete h3;h3 = NULL;

}
#endif // _DEBUG