设计模式-行为-Command（命令）模式

Command（命令）模式的核心思想是将行为的请求者与执行者解耦，从而支持撤销/重做等处理需求。

实现上并不复杂：将请求封装到一个 Command 类中，提供处理对象（Receiver），最后由 Invoker 调用 Execute。

• 可以通过回调的方式将处理对象封装为参数传入 Command，可用函数指针，也可用匿名函数（lambda）。
• 处理对象（Receiver）可以有多个处理函数，分别应对不同的命令。
• 处理对象（Receiver）也可以只有一个统一的处理函数，通过传入 RTTI 类型信息来确定具体操作，实现统一的处理接口。

例1：基础结构

class Receiver
                {
                public:
                	virtual void Action()
                	{
                		cout << __FUNCTION__ << endl;
                	}
                };
                
                
                
                
                class Command
                {
                public:
                	virtual void Execute() = 0;
                
                protected:
                	Receiver*recver;
                
                };
                
                
                
                class ConCreateCommand :public Command
                {
                public:
                	virtual void Execute()override
                	{
                		recver->Action();
                	}
                
                	ConCreateCommand(Receiver*recevier)
                	{
                		this->recver = recevier;
                	}
                
                };
                
                
                class Invoker
                {
                public:
                	void Invoke()
                	{
                		command->Execute();
                	}
                	Invoker(Command *com)
                	{
                		this->command = com;
                	}
                private:
                	Command*command;
                
                };
                
                
                void testCommand()
                {
                	Receiver *recv = new Receiver;
                	ConCreateCommand *com = new ConCreateCommand(recv);
                
                	Invoker *invoke = new Invoker(com);
                
                	invoke->Invoke();
                }

例2：多命令 Receiver

class ReceverTV
                	{
                	public:
                		void ActionVolumeUp()
                		{
                			cout << __FUNCTION__ << endl;
                		}
                		void ActionPowerOn()
                		{
                			cout << __FUNCTION__ << endl;
                		}
                
                	};
                
                
                
                	class Command
                	{
                	public:
                		virtual void Execute() = 0;
                
                	protected:
                		ReceverTV *recv;
                	};
                
                	class CommandOn :public Command
                	{
                	public:
                		virtual void Execute()override
                		{
                			cout << "power on" << endl;
                			recv->ActionPowerOn();
                
                		}
                		CommandOn(ReceverTV *tv)
                		{
                			recv = tv;
                		}
                	};
                
                	class CommandVolumeUp :public Command
                	{
                	public:
                		virtual void Execute()
                		{
                			cout << "volume up" << endl;
                			recv->ActionVolumeUp();
                		}
                		CommandVolumeUp(ReceverTV *tv)
                		{
                			recv = tv;
                		}
                	};
                	class Invoker
                	{
                
                	public:
                		void Invoke()
                		{
                			com->Execute();
                		}
                		Invoker(Command *com)
                		{
                			this->com = com;
                		}
                	private:
                		Command*com;
                	};
                
                
                
                
                	void testCommand2()
                	{
                		ReceverTV*tv = new ReceverTV();
                
                		auto *on = new CommandVolumeUp(tv);
                
                		Invoker *invoke = new Invoker(on);
                		invoke->Invoke();
                
                	}
                
                
                	void testCommand3()
                	{
                		ReceverTV*tv = new ReceverTV();
                		auto *on = new CommandVolumeUp(tv);
                
                		on->Execute();
                	}

例3：回调方式（std::function）

#include <functional>
                
                
                
                	class Receiver
                	{
                	public:
                		virtual void Action()
                		{
                			cout << __FUNCTION__ << endl;
                		}
                	};
                
                
                	class Command
                	{
                	public:
                		virtual void Execute() = 0;
                	};
                
                
                	class CallbackCommand :public Command
                	{
                	public:
                		virtual void Execute()override
                		{
                			if (recever)
                				recever();
                		}
                		CallbackCommand(const std::function<void(void)>& recever)
                		{
                			this->recever = recever;
                		}
                	private:
                		std::function<void(void)> recever = nullptr;
                
                	};
                
                
                	void testCommand4()
                	{
                		Receiver *rev = new Receiver;
                		Command *com = new CallbackCommand([=]()
                		{
                			rev->Action();
                		});
                		com->Execute();
                
                		//RTTI
                	//	cout << typeid(com).hash_code();
                
                		cout << (unsigned int)(com) << endl;;
                
                
                
                
                		{
                			Receiver *rev = new Receiver;
                			Command *com = new CallbackCommand([=]()
                			{
                				rev->Action();
                			});
                			com->Execute();
                
                			//RTTI
                			//cout << typeid(com).hash_code();
                			cout << (unsigned int)(com) << endl;
                
                
                		}
                	//	cout <<  (unsigned int)(com);
                
                
                
                	}