09 命令（Command）模式

最新推荐文章于 2024-05-31 14:42:05 发布
最新推荐文章于 2024-05-31 14:42:05 发布
阅读量158 收藏
点赞数
分类专栏： c++设计模式 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zzyzxb/article/details/125709918
版权

命令（Command）模式:行为型模式。

一：通过一个范例引出命令模式代码编写方法

红烧鱼，锅包肉

using namespace std;

namespace nmsp1
{
	//厨师类
	class Cook
	{
	public:
		//做红烧鱼
		void cook_fish()
		{
			cout << "做一盘红烧鱼菜品" << endl;
		}

		//做锅包肉
		void cook_meat()
		{
			cout << "做一盘锅包肉菜品" << endl;
		}
		//做其他各种菜品......略
	};
}

int main()
{
	_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);//程序退出时检测内存泄漏并显示到“输出”窗口

	nmsp1::Cook* pcook = new nmsp1::Cook();
	pcook->cook_fish();
	pcook->cook_meat();

	//释放资源
	delete pcook;

	std::cout << "主线程执行完毕\n";
}

二：引入命令（Command）模式：五种角色

using namespace std;

namespace nmsp1
{
	//厨师类
	class Cook
	{
	public:
		//做红烧鱼
		void cook_fish()
		{
			cout << "做一盘红烧鱼菜品" << endl;
		}

		//做锅包肉
		void cook_meat()
		{
			cout << "做一盘锅包肉菜品" << endl;
		}
		//做其他各种菜品......略
	};

	//----------------------
	//厨师做的每样菜品对应的抽象类
	class Command
	{
	public:
		Command(Cook* pcook)
		{
			m_pcook = pcook;
		}
		//做父类时析构函数为虚函数
		virtual ~Command()
		{
		}
		virtual void Execute() = 0;

	protected:
		Cook* m_pcook;  //子类需要访问
	};

	//做红烧鱼菜品命令
	class CommandFish :public Command
	{
	public:
		CommandFish(Cook* pcook) :Command(pcook) {}
		virtual void Execute()
		{
			m_pcook->cook_fish();
		}
	};

	//做锅包肉菜品命令
	class CommandMeat :public Command
	{
	public:
		CommandMeat(Cook* pcook) :Command(pcook) {}
		virtual void Execute()
		{
			m_pcook->cook_meat();  //将一个动作封装成了一个对象
		}
	};

	//----------------------
	//服务员类
	class Waiter
	{
	public:
		void SetCommand(Command* pcommand)  //顾客把便签交给服务员
		{
			m_pcommand = pcommand;
		}
		void Notify()  //服务器员将便签交到厨师手里让厨师开始做菜
		{
			m_pcommand->Execute();
		}

	private:
		Command* m_pcommand;  //服务员手中握着顾客书写的菜品便签
	};
}

int main()
{
	_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);//程序退出时检测内存泄漏并显示到“输出”窗口

	//nmsp1::Cook cook;
	//nmsp1::Command* pcmd1 = new nmsp1::CommandFish(&cook);
	//pcmd1->Execute();  //做红烧鱼
	//nmsp1::Command* pcmd2 = new nmsp1::CommandMeat(&cook);
	//pcmd2->Execute();  //做锅包肉
	释放资源
	//delete pcmd1;
	//delete pcmd2;

	nmsp1::Cook cook;
	nmsp1::Waiter* pwaiter = new nmsp1::Waiter();

	nmsp1::Command* pcmd1 = new nmsp1::CommandFish(&cook);
	pwaiter->SetCommand(pcmd1);
	pwaiter->Notify();  //做红烧鱼

	nmsp1::Command* pcmd2 = new nmsp1::CommandMeat(&cook);
	pwaiter->SetCommand(pcmd2);
	pwaiter->Notify();  //做锅包肉

	//释放资源
	delete pcmd1;
	delete pcmd2;
	delete pwaiter;

	std::cout << "主线程执行完毕\n";
	return 0;
}

using namespace std;

namespace nmsp1
{
	//厨师类
	class Cook
	{
	public:
		//做红烧鱼
		void cook_fish()
		{
			cout << "做一盘红烧鱼菜品" << endl;
		}

		//做锅包肉
		void cook_meat()
		{
			cout << "做一盘锅包肉菜品" << endl;
		}
		//做其他各种菜品......略
	};

	//----------------------
	//厨师做的每样菜品对应的抽象类
	class Command
	{
	public:
		Command(Cook* pcook)
		{
			m_pcook = pcook;
		}
		//做父类时析构函数为虚函数
		virtual ~Command()
		{
		}
		virtual void Execute() = 0;

	protected:
		Cook* m_pcook;  //子类需要访问
	};

	//做红烧鱼菜品命令
	class CommandFish :public Command
	{
	public:
		CommandFish(Cook* pcook) :Command(pcook) {}
		virtual void Execute()
		{
			m_pcook->cook_fish();
		}
	};

	//做锅包肉菜品命令
	class CommandMeat :public Command
	{
	public:
		CommandMeat(Cook* pcook) :Command(pcook) {}
		virtual void Execute()
		{
			m_pcook->cook_meat();  //将一个动作封装成了一个对象
		}
	};

	//服务员类
	class Waiter
	{
	public:
		//将顾客的便签增加到便签列表中，即便一个便签中包含多个菜品，这也相当于一道一道菜品加入到列表中
		void AddCommand(Command* pcommand)
		{
			m_commlist.push_back(pcommand);
		}

		//如果顾客想撤单则将便签从列表中删除
		void DelCommand(Command* pcommand)
		{
			m_commlist.remove(pcommand);
		}

		void Notify()  //服务员将所有便签一次性交到厨师手里让厨师开始按顺序做菜
		{
			//依次让厨师做每一道菜品
			for (auto iter = m_commlist.begin(); iter != m_commlist.end(); ++iter)
			{
				(*iter)->Execute();
			}
		}

	private:
		//一个便签中可以包含多个菜品甚至可以一次收集多个顾客的便签，达到一次性通知厨师做多道菜的效果
		std::list<Command*> m_commlist;  //菜品列表，每道菜品作为一项，如果一个便签中有多个菜品，则这里将包含多项
	};

	//--------------------
	//实习服务器员类
	class Traineewaiter
	{
	public:
		Traineewaiter(Command* pcommand) :m_pcommand(pcommand) {} //构造函数
		void Notify() //实习服务员将便签交到厨师手里让厨师开始做菜
		{
			m_pcommand->Execute();
		}
		~Traineewaiter() //析构函数
		{
			if (m_pcommand != nullptr)
			{
				delete m_pcommand;
				m_pcommand = nullptr;
			}
		}

	private:
		Command* m_pcommand; //实习服务员手中握着顾客书写的菜品便签
	};
}

int main()
{
	_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);//程序退出时检测内存泄漏并显示到“输出”窗口

	nmsp1::Cook cook;
	//一次性在便签上写下多道菜品
	nmsp1::Command* pcmd1 = new nmsp1::CommandFish(&cook);
	nmsp1::Command* pcmd2 = new nmsp1::CommandMeat(&cook);
		 
	nmsp1::Waiter* pwaiter = new nmsp1::Waiter();
	//把多道菜品分别加入到菜品列表
	pwaiter->AddCommand(pcmd1);
	pwaiter->AddCommand(pcmd2);

	//服务员一次性通知厨师做多道菜
	pwaiter->Notify();

	//释放资源
	delete pcmd1;
	delete pcmd2;
	delete pwaiter;

	std::cout << "主线程执行完毕\n";
	return 0;
}

命令模式UML图
命令模式UML图

<1>Receiver（接收者类）：Cook类，cook_fish、cook_meat。
<2>Invoker（调用者类）：Waiter类。
<3>Command（抽象命令类）：Command类。
<4>ConcreteCommand（具体命令类）：CommandFish类和CommandMeat类。
<5>Client（客户端）。

定义：将一个请求或命令封装为一个对象，以便这些请求可以以对象的方式通过参数进行传递，对象化了的请求还可以排队执行或者根据需要将这些请求录入日志供查看和排错，以及支持请求执行后的可撤销操作。

能力：对请求进行封装，命令对象将动作和接收者包裹到了对象中，并且只暴露了一个Execute方法让接收者执行动作。

三：命令模式用途研究

异步执行、延迟执行、排队执行、撤销、执行过程中增加日志记录等，是命令模式主要应用场景。

<1>改造范例增加对象使用时的独立性

#ifdef _DEBUG   //只在Debug（调试）模式下
#ifndef DEBUG_NEW
#define DEBUG_NEW new(_NORMAL_BLOCK,__FILE__,__LINE__) //重新定义new运算符
#define new DEBUG_NEW
#endif
#endif

using namespace std;

namespace nmsp1
{
	//厨师类
	class Cook
	{
	public:
		//做红烧鱼
		void cook_fish()
		{
			cout << "做一盘红烧鱼菜品" << endl;
		}

		//做锅包肉
		void cook_meat()
		{
			cout << "做一盘锅包肉菜品" << endl;
		}
		//做其他各种菜品......略
	};

	//----------------------
	//厨师做的每样菜品对应的抽象类
	class Command
	{
	public:
		Command(Cook* pcook)
		{
			m_pcook = pcook;
		}
		//做父类时析构函数为虚函数
		virtual ~Command()
		{
			if (m_pcook != nullptr)
			{
				delete m_pcook;
				m_pcook = nullptr;
			}
		}
		virtual void Execute() = 0;

	protected:
		Cook* m_pcook;  //子类需要访问
	};

	//做红烧鱼菜品命令
	class CommandFish :public Command
	{
	public:
		CommandFish(Cook* pcook) :Command(pcook) {}
		virtual void Execute()
		{
			m_pcook->cook_fish();
		}
	};

	//做锅包肉菜品命令
	class CommandMeat :public Command
	{
	public:
		CommandMeat(Cook* pcook) :Command(pcook) {}
		virtual void Execute()
		{
			m_pcook->cook_meat();  //将一个动作封装成了一个对象
		}
	};

	//服务员类
	class Waiter
	{
	public:
		//将顾客的便签增加到便签列表中，即便一个便签中包含多个菜品，这也相当于一道一道菜品加入到列表中
		void AddCommand(Command* pcommand)
		{
			m_commlist.push_back(pcommand);
		}

		//如果顾客想撤单则将便签从列表中删除
		void DelCommand(Command* pcommand)
		{
			m_commlist.remove(pcommand);
		}

		void Notify()  //服务员将所有便签一次性交到厨师手里让厨师开始按顺序做菜
		{
			//依次让厨师做每一道菜品
			for (auto iter = m_commlist.begin(); iter != m_commlist.end(); ++iter)
			{
				(*iter)->Execute();
			}
		}

	private:
		//一个便签中可以包含多个菜品甚至可以一次收集多个顾客的便签，达到一次性通知厨师做多道菜的效果
		std::list<Command*> m_commlist;  //菜品列表，每道菜品作为一项，如果一个便签中有多个菜品，则这里将包含多项
	};

	//--------------------
	//实习服务器员类
	class Traineewaiter
	{
	public:
		Traineewaiter(Command* pcommand) :m_pcommand(pcommand) {}  //构造函数
		void Notify()  //实习服务员将便签交到厨师手里让厨师开始做菜
		{
			m_pcommand->Execute();
		}
		~Traineewaiter()  //析构函数
		{
			if (m_pcommand != nullptr)
			{
				delete m_pcommand;
				m_pcommand = nullptr;
			}
		}

	private:
		Command* m_pcommand;  //实习服务员手中握着顾客书写的菜品便签
	};

	//-------------------------
	//宏命令：把多个命令组合
	class CommandMacro :public Command
	{
	public:
		void AddCommand(Command* pcommand)
		{
			m_commlist.push_back(pcommand);
		}
		virtual void Execute()
		{
			for (auto iter = m_commlist.begin(); iter != m_commlist.end(); ++iter)
			{
				(*iter)->Execute();
			}
		}

	private:
		std::list<Command*> m_commlist;
	};
}

int main()
{
	_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);//程序退出时检测内存泄漏并显示到“输出”窗口

	nmsp1::Cook cook;
	//一次性在便签上写下多道菜品
	nmsp1::Command* pcmd1 = new nmsp1::CommandFish(&cook);
	nmsp1::Command* pcmd2 = new nmsp1::CommandMeat(&cook);  //有析构函数delete后，为什么会报错？？？
	//nmsp1::Command* pcmd1 = new nmsp1::CommandFish(new nmsp1::Cook());
	//nmsp1::Command* pcmd2 = new nmsp1::CommandMeat(new nmsp1::Cook());  

	//nmsp1::Waiter* pwaiter = new nmsp1::Waiter();
	把多道菜品分别加入到菜品列表
	//pwaiter->AddCommand(pcmd1);
	//pwaiter->AddCommand(pcmd2);

	服务员一次性通知厨师做多道菜
	//pwaiter->Notify();

	释放资源
	//delete pcmd1;
	//delete pcmd2;
	//delete pwaiter;

	nmsp1::Traineewaiter* pwaitersx1 = new nmsp1::Traineewaiter(new nmsp1::CommandFish(new nmsp1::Cook()));
	pwaitersx1->Notify();  //做红烧鱼

	nmsp1::Traineewaiter* pwaitersx2 = new nmsp1::Traineewaiter(new nmsp1::CommandMeat(new nmsp1::Cook()));
	pwaitersx2->Notify();  //做锅包肉

	delete pwaitersx1;
	delete pwaitersx2;

	std::cout << "主线程执行完毕\n";
	return 0;
}

<2>命令模式使用场景谈与特点总结

（1）在一些绘图软件中，撤销的实现使用命令模式。
（2）遥控器实现对控制设备的解耦。
（3）任务的定期调度执行：Task Scheduler。
（4）游戏中时光倒流系统和回放系统的实现。

命令模式的特点：

问题思考：

（1）命令对象作为回调函数的替代：Command模式是回调机制的一个面向对象的替代品。
（2）极端情形：不引入调用者类；Command子类自己实现相关功能不引入接收者。
（3）命令模式中命令对象与现代C++中可调用对象的比较。

class TC
{
public:
	void operator()(int tv)
	{
		cout << "TC::Operator(int tv)执行了，tv = " << tv << endl;
	}
	int operator()(int tv1, int tv2)
	{
		cout << "TC::Operator(int tv1, int tv2)执行了，tv1 = " << tv1 << ", tv2 = " << tv2 << endl;
		return 1;
	}
};

template <class T>  //T代表可调用对象的类型
void functmptest(T callobj)  //callobj是个可调用对象
{
	callobj(100);
	return;
}

int main()
{
	TC tc;
	tc(20);  //调用的是()操作符，这就是可调用对象。等价于tc.operator()(20);
	tc(30, 50);
	functmptest(tc);

	std::cout << "主线程执行完毕\n";
	return 0;
}
zzyzxb
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
命令模式（Command）
IT界的一只菜鸟
08-02 1万+
18、命令模式（Command） 命令模式很好理解，举个例子，司令员下令让士兵去干件事情，从整个事情的角度来考虑，司令员的作用是，发出口令，口令经过传递，传到了士兵耳朵里，士兵去执行。这个过程好在，三者相互解耦，任何一方都不用去依赖其他人，只需要做好自己的事儿就行，司令员要的是结果，不会去关注到底士兵是怎么实现的。我们看看关系图： Invoker是调用者（司令员），Receiver是被调用...
命令(command)模式
03-17
NULL 博文链接：https://zcl198715.iteye.com/blog/561121
设计模式（18）－Command Pattern
weixin_30275415的博客
09-26 147
一、命令（Command）模式 命令（Command）模式属于对象的行为模式【GOF95】。命令模式又称为行动（Action）模式或交易（Transaction）模式。命令模式把一个请求或者操作封装到一个对象中。命令模式允许系统使用不同的请求把客户端参数化，对请求排队或者记录请求日志，可以提供命令的撤销和恢复功能。 命令模式是对命令的封装。命令模式把发出命令的责任和执行命令的责任分割开，...
命令模式
chrml927423的博客
08-21 93
命令模式：将“请求”封装成对象，以便使用不同的请求、队列或者日志来参数化其他对象。命令模式也支持可撤销的操作。 将命令封装成对象中，具有以下作用： 使用命令来参数化其它对象 将命令放入队列中进行排队 将命令的操作记录到日志中 支持可撤销的操作 类图： ...
Command模式（命令设计模式）
weixin_30687587的博客
11-04 152
Command？？ 把方法的调用用一个类的实例来承载，要管理工作的历史记录，创建这些方法执行的命令的集合，只需管理这些实例的集合即可，而且还可以随时再次执行过去的命令，或是将多个过去的命令整合为一个新命令并执行。称之为Command设计模式 那里合适使用： Command有时也被称为事件（event）。它与“事件驱动编程”中的“事件”是一样的意思。当发生点击鼠标、按下键盘按键等事件时，...
命令模式（Command模式）
qq_35784669的博客
11-09 490
在软件开发系统中，“方法的请求者”与“方法的实现者”之间经常存在紧密的耦合关系，这不利于软件功能的扩展与维护。例如，想对方法进行“撤销、重做、记录”等处理都很不方便，因此“如何将方法的请求者与实现者解耦？”变得很重要，命令模式就能很好地解决这个问题。 在现实生活中，命令模式的例子也很多。比如看电视时，我们只需要轻轻一按遥控器就能完成频道的切换，这就是命令模式，将换台请求和换台处理完全解耦了。电视机遥控器（命令发送者）通过按钮（具体命令）来遥控电视机（命令接收者）。 再比如，我们去餐厅吃饭，菜单不是等到客人来
PHP命令Command模式用法实例分析
10-18
主要介绍了PHP命令Command模式用法,结合实例形式分析了命令模式的概念、原理、使用方法及相关操作注意事项,需要的朋友可以参考下
命令模式（Command）原理图
04-16
命令模式是一种行为设计模式，它将一个请求封装成一个对象，从而允许用户根据不同的请求对客户进行参数化；同时，它也支持撤销操作。 命令模式的核心在于通过命令对象实现调用操作和实现操作的解耦。这种模式通常...
设计模式C++学习之命令模式（Command）
09-07
设计模式C++学习之命令模式（Command）
命令模式(Command Pattern).rar
01-05
用最简单的例子理解命令模式(Command Pattern) 命令模式的需求源自想通过一个指令(比如这里IControl的Execute方法)来控制多个类的多个方法，包含了几个要素： 1、命令：让类的各种方法抽象成类实现一个接口 2、...
命令（Command）模式
梵法利亚的博客
10-05 438
在软件开发系统中，常常出现“方法的请求者”与“方法的实现者”之间存在紧密的耦合关系。这不利于软件功能的扩展与维护。例如，想对行为进行“撤销、重做、记录”等处理都很不方便，因此“如何将方法的请求者与方法的实现者解耦？”变得很重要，命令模式能很好地解决这个问题。 在现实生活中，这样的例子也很多，例如，电视机遥控器（命令发送者）通过按钮（具体命令）来遥控电视机（命令接收者），还有计算机键盘上的“功能键”等。 什么是命令（Command）模式？ 命令（Command）模式的定义如下：将一个请求封装为一个对象，使发出
命令(Command)模式
qq_38636211的博客
07-30 643
文章目录命令(Command)模式1. 意图2. 别名3. 动机4. 适用性5. 结构6. 参与者7. 协作8. 效果9. 实现10. 代码示例11. 已知应用12. 相关应用13. 设计原则口袋14. 参考文献 命令(Command)模式 隶属类别——对象行为型模式 1. 意图 将一个请求封装成一个对象，以便使用不同的请求、队列或者日志来参数化(使用统一的语言去调用，例如遥控器插插槽根本不在乎...
设计模式之命令模式（Command）
菜????一只
08-17 266
从发出者发出命令，发出者不用关心谁接收命令，只要把命令发出即可从接收者接收命令，接收者不用关心谁发出命令，只要把每次命令接收接收者也可以看成命令执行者。
设计模式(21）-- 命令模式
baidu_21349635的专栏
12-11 207
文章目录命令模式基本介绍命令模式的原理类图命令模式解决智能生活项目命令模式在Spring框架JdbcTemplate应用的源码分析命令模式的注意事项和细节 命令模式基本介绍 命令模式的原理类图 命令模式解决智能生活项目 LightReceiver Command NoCommand LightOnCommand LightOffCommand TVReceiver pub...
command设计模式和回调机制
836811384
07-16 476
总结command设计模式和回调机制，说明这两者之间的联系，并且用command模式来实现回调机制。command设计模式是回调机制的一个面向对象的替代品。 一、首先介绍回调机制 回调机制：一开始，一个类定义了一些个未实现的方法，并且该类并不知道这些方法具体的实现是怎么样的，因为只有等到运行时候才能够知道这些方法的具体实现。等到具体要用到该类对象的时候，才对该类中的抽象方法定义实现。该实现的过...
漫谈设计模式之命令模式（Command）
纯屌丝程序猿
04-23 362
概念Command模式也叫命令模式，是行为设计模式的一种，Command模式通过被称为Command的类封装了对目标对象的调用行为以及调用参数。 在面向对象的程序设计中，一个对象调用另一个对象，一般情况下的调用过程是：创建目标对象实例--&gt;设置调用参数--&gt;抵用目标对象的方法。但在有些情况下有必要使用一个专门的类对这种调用过程加以封装，我们把这种专门的类称作command类。整个调用过...
命令模式（Command Pattern）
jiangxt211的专栏
11-30 243
命令模式（Command pattern），将一个请求封装为一个对象，从而使你可以用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤销的操作。 别名 动作(Action)，事务(Transcation)。 使用性 1）抽象出待执行的动作以参数化某对象。你可用过程语言中的回调（callback）函数表达这种参数化机制。所谓回调函数是指函数先在某处注册，而它将在稍后某个需要的
C++中的智能指针类别
最新发布
GOLOJO的博客
05-31 658
C++中的智能指针是用来管理动态内存的对象，避免我们手动管理内存时可能会带来的复杂性和错误。C++标准库提供了几种不同类型的智能指针，包括``、``和`- 优先使用``和``来创建智能指针，避免手动使用`new`，可以提高代码的安全性和性能。- 在使用``时要特别小心循环引用的问题。可以使用``来打破循环引用。- 确保智能指针的生命周期管理正确，避免悬空指针和内存泄漏。- 虽然智能指针极大地简化了内存管理，但也带来了额外的开销，如引用计数的维护。因此，在性能敏感的代码中，应慎重使用`
精通C++ STL（二）：string类的模拟实现
Russ_Leo的博客
05-27 797
string类各函数接口。
video模式和command模式
09-07
video模式和command模式是指在计算机领域中两种不同的操作界面或交互方式。 1. Video模式（图形用户界面）：Video模式是指使用图形用户界面（GUI）进行操作的模式。在这种模式下，计算机系统以图像、图标和视觉效果...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值