面向对象设计模式--命令模式（C++可执行代码）

Frunze软件开发

于 2024-04-17 16:51:38 发布

阅读量1k

点赞数 25

CC 4.0 BY-SA版权

分类专栏： C++ 面向对象设计模式文章标签：设计模式命令模式 c++

本文链接：https://blog.youkuaiyun.com/weixin_40978412/article/details/137879089

C++ 面向对象设计模式专栏收录该内容

23 篇文章

订阅专栏

本文介绍了命令模式如何解决GUI编程中按钮操作的代码重复和依赖问题，通过将操作细节封装在命令对象中，实现请求的解耦和可扩展性，支持撤销操作和延迟执行。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

命令模式

（Command）

命令是一种行为设计模式，它可将请求转换为一个包含与请求相关的所有信息的独立对象。该转换让你能根据不同的请求将方法参数化、延迟请求执行或将其放入队列中，且能实　现可撤销操作。

1. 问题

假如你正在开发一款新的文字编辑器，当前的任务是创建一个包含多个按钮的工具栏，并让每个按钮对应编辑器的不同操作。你创建了一个非常简洁的按钮类，它不仅可用于生成工具栏上的按钮，还可用于生成各种对话框的通用按钮。

应用中的所有按钮都可以继承相同的类

尽管所有按钮看上去都很相似，但它们可以完成不同的操作（打开、保存、打印和应用等）。你会在哪里放置这些按钮的点击处理代码呢？最简单的解决方案是在使用按钮的每个地方都创建大量的子类。这些子类中包含按钮点击后必须执行的代码。

大量的按钮子类。没关系的。

你很快就意识到这种方式有严重缺陷。首先，你创建了大量的子类，当每次修改基类按钮时，你都有可能需要修改所有子类的代码。简单来说，GUI 代码以一种拙劣的方式依赖于业务逻辑中的不稳定代码。

多个类实现同一功能

还有一个部分最难办。复制/粘贴文字等操作可能会在多个地方被调用。例如用户可以点击工具栏上小小的“复制”按钮，或者通过上下文菜单复制一些内容，又或者直接使用键盘上的 Ctrl+C 。

我们的程序最初只有工具栏，因此可以使用按钮子类来实现各种不同操作。换句话来说，复制按钮 CopyButton 子类包含复制文字的代码是可行的。在实现了上下文菜单、快捷方式和其他功能后，你要么需要将操作代码复制进许多个类中，要么需要让菜单依赖于按钮，而后者是更糟糕的选择。

2. 解决方案

优秀的软件设计通常会将关注点进行分离，而这往往会导致软件的分层。最常见的例子：一层负责用户图像界面；另一层负责业务逻辑。GUI 层负责在屏幕上渲染美观的图形，捕获所有输入并显示用户和程序工作的结果。当需要完成一些重要内容时（比如计算月球轨道或撰写年度报告），GUI 层则会将工作委派给业务逻辑底层。

这在代码中看上去就像这样：一个 GUI 对象传递一些参数来调用一个业务逻辑对象。这个过程通常被描述为一个对象发送请求给另一个对象。

GUI 层可以直接访问业务逻辑层。

命令模式建议 GUI 对象不直接提交这些请求。你应该将请求的所有细节（例如调用的对象、方法名称和参数列表）抽取出来组成命令类，该类中仅包含一个用于触发请求的方法。命令对象负责连接不同的 GUI 和业务逻辑对象。此后，GUI对象无需了解业务逻辑对象是否获得了请求，也无需了解其对请求进行处理的方式。GUI 对象触发命令即可，命令对象会自行处理所有细节工作。

通过命令访问业务逻辑层。

下一步是让所有命令实现相同的接口。该接口通常只有一个没有任何参数的执行方法，让你能在不和具体命令类耦合的情况下使用同一请求发送者执行不同命令。此外还有额外的好处，现在你能在运行时切换连接至发送者的命令对象，以此改变发送者的行为。

你可能会注意到遗漏的一块拼图——请求的参数。GUI 对象可以给业务层对象提供一些参数。但执行命令方法没有任何参数，所以我们如何将请求的详情发送给接收者呢？答案是：使用数据对命令进行预先配置，或者让其能够自行获取数据。

GUI 对象将命令委派给命令对象。

让我们回到文本编辑器。应用命令模式后，我们不再需要任何按钮子类来实现点击行为。我们只需在按钮 Button 基类中添加一个成员变量来存储对于命令对象的引用，并在点击后执行该命令即可。

你需要为每个可能的操作实现一系列命令类，并且根据按钮所需行为将命令和按钮连接起来。

其他菜单、快捷方式或整个对话框等 GUI 元素都可以通过相同方式来实现。当用户与 GUI 元素交互时，与其连接的命令将会被执行。现在你很可能已经猜到了，与相同操作相关的元素将会被连接到相同的命令，从而避免了重复代码。

最后，命令成为了减少 GUI 和业务逻辑层之间耦合的中间层。而这仅仅是命令模式所提供的一小部分好处！

3. 结构

命令模式的结构

其中：

*Command声明执行操作的接口。

*Concrete Command将一个接收者对象绑定于一个动作；调用接收者相应的操作，以实现Execute。

*Client创建一个具体命令对象并设定它的接收者。

*Invoker要求该命令执行这个请求。

*Receiver知道如何实施与执行一个请求相关的操作。任何类都可能作为一个接收者。

4. 实现方式

1. 声明仅有一个执行方法的命令接口。

2. 抽取请求并使之成为实现命令接口的具体命令类。

每个类都必须有一组成员变量来保存请求参数和对于实际接收者对象的引用。所有这些变量的数值都必须通过命令构造函数进行初始化。

3. 找到担任发送者职责的类。

在这些类中添加保存命令的成员变量。发送者只能通过命令接口与其命令进行交互。发送者自身通常并不创建命令对象，而是通过客户端代码获取。

4. 修改发送者使其执行命令，而非直接将请求发送给接收者。

5. 客户端必须按照以下顺序来初始化对象：

◦ 创建接收者。

◦ 创建命令，如有需要可将其关联至接收者。

◦ 创建发送者并将其与特定命令关联。

5. 代码示例

command.h

#ifndef DESIGN_PATTERNS_COMMAND_H
#define DESIGN_PATTERNS_COMMAND_H
#include <iostream>
#include <string>
#include <vector>
using namespace std;
//------------------------------//
class Barbecuer //“烧烤”类
{
public:
	void BakeMutton();//烤羊肉
	void BakeChicken();//烤鸡肉
};
//------------------------------//
class Command //"指令"类
{
public:
	Command() {}
	Command(Barbecuer*);
	virtual ~Command() {}
	virtual void ExecuteCommand() = 0;//执行指令

protected:
	Barbecuer* barbecuer_;
};

class BakeMuttonCommand : public Command 
{
public:
	BakeMuttonCommand() {}
	BakeMuttonCommand(Barbecuer*);
	void ExecuteCommand();//执行指令
};

class BakeChickenCommand : public Command 
{
public:
	BakeChickenCommand() {}
	BakeChickenCommand(Barbecuer*);
	void ExecuteCommand();//执行指令
};
//------------------------------//
class Waiter //“服务员”类
{
public:
	void SetOrder(Command*);//设置指令
	void CancelOrder(Command*);//取消指令
	void Notify();//通知

protected:
	vector <Command*> commands_;
};
//------------------------------//
#endif //DESIGN_PATTERNS_COMMAND_H

command.c

#include "command.h"
#include <typeinfo>
//------------------------------//
void Barbecuer::BakeMutton() 
{
	cout << "烤羊肉" << endl;
}
void Barbecuer::BakeChicken() 
{
	cout << "烤鸡肉" << endl;
}
//------------------------------//
Command::Command(Barbecuer *barbecuer) : barbecuer_(barbecuer) {}
//------------------------------//
BakeMuttonCommand::BakeMuttonCommand(Barbecuer *barbecuer) : Command(barbecuer) {}

void BakeMuttonCommand::ExecuteCommand() 
{
	barbecuer_->BakeMutton();
}
//------------------------------//
BakeChickenCommand::BakeChickenCommand(Barbecuer *barbecuer) : Command(barbecuer) {}

void BakeChickenCommand::ExecuteCommand() 
{
	barbecuer_->BakeChicken();
}
//------------------------------//
void Waiter::SetOrder(Command *command) 
{
	if (dynamic_cast<BakeChickenCommand*>(command))
	{
		cout << "鸡肉卖完了" << endl;
	}
	else 
	{
		commands_.push_back(command);
		cout << "设置命令: " << string(typeid(*command).name()).substr(2) << endl;
	}
}

void Waiter::CancelOrder(Command *command) 
{
	for (vector <Command*> ::iterator it = commands_.begin(); it != commands_.end(); ++it) 
	{
		if (*it == command) 
		{
			commands_.erase(it);
			cout << "取消命令: " << string(typeid(*command).name()).substr(2) << endl;
			return;
		}
	}
}

void Waiter::Notify() 
{
	for (vector<Command *>::iterator it = commands_.begin(); it != commands_.end(); ++it) 
	{
		(*it)->ExecuteCommand();
	}
}
//------------------------------//

Main.c

//------------------------------//
#include <iostream>
#include "command.h"
using namespace std;
//------------------------------//
// Created by Cls on 2024/04/01.
//------------------------------//
int main(int argc, char *argv[])
{
	Barbecuer *barbecuer_;
	Command *bake_mutton_command1_;
	Command *bake_mutton_command2_;
	Command *bake_chicken_command_;
	Waiter *waiter_;
	//-----------------//
	barbecuer_ = new Barbecuer();
	bake_mutton_command1_ = new BakeMuttonCommand(barbecuer_);
	bake_mutton_command2_ = new BakeMuttonCommand(barbecuer_);
	bake_chicken_command_ = new BakeChickenCommand(barbecuer_);
	waiter_ = new Waiter();

	waiter_->SetOrder(bake_mutton_command1_);
	waiter_->SetOrder(bake_mutton_command2_);
	waiter_->SetOrder(bake_chicken_command_);
	waiter_->CancelOrder(bake_mutton_command2_);
	cout << "------------------" << endl;

	waiter_->Notify();
	cout << "------------------" << endl;

	//-----------------//
	delete barbecuer_;
	delete bake_mutton_command1_;
	delete bake_mutton_command2_;
	delete bake_chicken_command_;
	delete waiter_;
	//-----------------//
	return 0;
}
//------------------------------//

打印输出