突破编程_C++_设计模式（命令模式）-Toy模板网

这篇具有很好参考价值的文章主要介绍了突破编程_C++_设计模式（命令模式）。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

1 命令模式的基本概念

C++ 命令模式是一种设计模式，它允许将请求封装为一个对象，从而可以用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤销的操作。命令模式的主要目的是将请求封装为对象，从而可以使用不同的请求把客户端与接收者解耦。

在命令模式中，通常包含以下几个关键角色：

（1）命令（Command）： 这是一个抽象类，它声明了执行操作的接口。具体的命令类会实现这个接口，并绑定到一个接收者对象上。当命令对象被调用时，它会调用接收者的相应操作。

（2）具体命令（ConcreteCommand）： 这是命令接口的具体实现类，它持有一个接收者对象，并实现了命令接口中的执行方法。当执行方法被调用时，它会调用接收者的相应方法来完成请求的操作。

（3）请求者（Invoker）： 请求者负责调用命令对象的执行方法。它不需要知道具体的命令对象类型，只需要知道它是一个命令对象即可。

（4）接收者（Receiver）： 接收者对象知道如何执行请求的操作。它具体实现了请求的功能。

2 命令模式的实现步骤

命令模式的实现步骤如下：

（1）定义命令接口：

创建一个抽象类（或接口），声明一个执行操作的方法。这个方法将是所有具体命令类共有的接口。

（2）实现具体命令类：

创建具体命令类，继承自命令接口。
在具体命令类中，通常包含一个指向接收者对象的指针（或引用）。
实现执行操作的方法，该方法内部调用接收者对象的相应方法来完成请求的操作。

（3）创建接收者类：

定义一个接收者类，它包含实际执行操作的逻辑。
接收者类的方法对应于命令类需要执行的操作。

（4）创建请求者类：

请求者类负责调用命令对象的执行方法。
请求者不需要知道具体的命令对象类型，它只需要持有一个命令对象的指针（或引用）。
请求者类可以存储多个命令对象，并按照需要调用它们的执行方法。

（5）将命令对象与接收者对象关联：

在创建具体命令对象时，将接收者对象传递给命令对象，以便命令对象在执行时可以调用接收者的方法。

（6）使用命令模式：

在客户端代码中，创建接收者对象。
创建与接收者对象关联的具体命令对象。
将命令对象传递给请求者对象。
请求者对象调用命令对象的执行方法，从而间接调用接收者的方法，完成请求的操作。

如下为样例代码：

#include <iostream>  
#include <memory>  
#include <string>  
#include <vector>  

// 创建接收者类  
class Receiver {
public:
	void action() {
		std::cout << "Receiver::action() called" << std::endl;
	}
};

// 定义命令接口  
class Command {
public:
	virtual ~Command() = default;
	virtual void execute() = 0;
};

// 实现具体命令类  
class ConcreteCommand : public Command {
public:
	ConcreteCommand(std::shared_ptr<Receiver> receiver) : m_receiver(receiver) {}
	void execute() override {
		m_receiver->action();
	}
private:
	std::shared_ptr<Receiver> m_receiver;
};

// 创建请求者类  
class Invoker {
public:
	void setCommand(std::unique_ptr<Command> command) {
		commands.push_back(std::move(command));
	}

	void executeCommands() {
		for (auto& cmd : commands) {
			cmd->execute();
		}
	}

private:
	std::vector<std::unique_ptr<Command>> commands;
};

// 客户端代码  
int main() 
{
	// 创建接收者对象  
	std::shared_ptr<Receiver> receiver = std::make_shared<Receiver>();

	// 创建具体命令对象，并与接收者对象关联  
	std::unique_ptr<Command> command = std::make_unique<ConcreteCommand>(receiver);

	// 创建请求者对象，并将命令对象传递给请求者  
	Invoker invoker;
	invoker.setCommand(std::move(command));

	// 请求者调用命令对象的执行方法  
	invoker.executeCommands(); // 输出: Receiver::action() called  

	return 0;
}

上面代码的输出为：

Receiver::action() called

在这个示例中：

Command 是一个抽象类，定义了命令的接口。
ConcreteCommand 是 Command 的具体实现，它持有一个指向 Receiver 的 shared_ptr，并在 execute 方法中调用 Receiver 的 action 方法。
Receiver 是接收者类，包含了实际要执行的操作。
Invoker 是请求者类，它持有一个 Command 对象的列表，并提供了一个方法来执行这些命令。

在 main 函数中，创建了 Receiver 对象和 ConcreteCommand 对象，并将 Receiver 对象传递给 ConcreteCommand 对象。然后将 ConcreteCommand 对象传递给 Invoker 对象，并调用 Invoker 的 executeCommands 方法来执行命令。最终，Receiver 的 action 方法被调用，输出了相应的信息。

3 命令模式的应用场景

C++命令模式的应用场景广泛，主要适用于以下情况：

（1）当功能需要支持撤销和恢复撤销操作时： 命令模式通过封装命令对象，可以方便地记录和执行命令历史，从而支持撤销和恢复撤销操作。这在图形编辑、文本编辑等应用中非常有用，例如，在绘制图形时，用户可以撤销最近的操作以返回到之前的状态。

（2）当需要设计一组命令，并且命令之间可以相互组合时： 命令模式支持将多个命令组合成一个复合命令，从而可以一次性执行多个操作。这在需要执行一系列相关操作时非常有用，例如，在编辑器中，用户可能希望将多个编辑操作（如剪切、复制、粘贴）组合成一个宏命令，以便一次性执行。

（3）当系统需要将命令发起者和命令执行者解耦时： 命令模式允许将请求封装为命令对象，从而使发送请求的对象和执行请求的对象解耦。这使得发送请求的对象不需要知道请求如何被完成，增加了系统的灵活性和可维护性。例如，在用户界面和后台逻辑之间，命令模式可以确保它们之间的松耦合，使得修改其中一方不会影响到另一方。

（4）当系统需要在不同时间指定、排列和执行请求时： 命令模式允许将命令对象存储在队列或列表中，然后根据需要按顺序执行它们。这对于实现批量操作、延迟执行或任务调度等功能非常有用。

总的来说，C++命令模式适用于需要解耦请求发送者和请求执行者、支持撤销操作、需要组合多个命令或在不同时间执行请求的场景。它能够提高系统的灵活性、可维护性和可扩展性。

3.1 命令模式应用于需要支持撤销和恢复撤销操作的场景

在 C++ 中，命令模式特别适用于需要支持撤销和恢复撤销操作的场景，如下为样例代码：

#include <iostream>  
#include <memory>  
#include <vector>  
#include <stack>  
#include <string>  

// 接收者类  
class Receiver {
public:
	std::string action() {
		std::string currentState = "New state"; // 假设这是某种状态  
		// 执行一些操作...  
		return currentState;
	}

	void restore(const std::string& state) {
		// 恢复到之前的状态...  
		std::cout << "Restoring to state: " << state << std::endl;
	}
};

// 命令接口  
class Command {
public:
	virtual ~Command() = default;
	virtual void execute() = 0;
	virtual void undo() = 0;
};

// 具体命令类  
class ConcreteCommand : public Command {
public:
	ConcreteCommand(std::shared_ptr<Receiver> receiver) : receiver(receiver) {}

	void execute() override {
		previousState = receiver->action();
		std::cout << "Command executed: " << previousState << std::endl;
	}

	void undo() override {
		receiver->restore(previousState);
		std::cout << "Command undone: " << previousState << std::endl;
	}

private:
	std::shared_ptr<Receiver> receiver;
	std::string previousState;
};

// 撤销管理器  
class UndoManager {
public:
	void executeCommand(std::shared_ptr<Command> cmd) {
		cmd->execute();
		commands.push(cmd);
	}

	void undoLastCommand() {
		if (!commands.empty()) {
			auto cmd = commands.top();
			commands.pop();
			cmd->undo();
		}
		else {
			std::cout << "No commands to undo." << std::endl;
		}
	}

private:
	std::stack<std::shared_ptr<Command>> commands;
};

int main() 
{
	// 创建接收者对象  
	auto receiver = std::make_shared<Receiver>();

	// 创建命令对象  
	auto command = std::make_shared<ConcreteCommand>(receiver);

	// 创建撤销管理器  
	UndoManager undoManager;

	// 执行命令  
	undoManager.executeCommand(command);

	// 撤销命令  
	undoManager.undoLastCommand();

	return 0;
}

上面代码的输出为：

Command executed: New state
Restoring to state: New state
Command undone: New state

在这个示例中：

Command 是一个抽象类，定义了命令的接口，包括 execute 和 undo 方法。
ConcreteCommand 是 Command 的具体实现，它持有一个指向 Receiver 的 shared_ptr，并在 execute 方法中执行操作，同时保存当前状态以便在 undo 方法中恢复。
Receiver 类包含实际执行操作的逻辑，以及一个 restore 方法用于恢复之前的状态。
UndoManager 类负责管理命令的撤销操作，它使用一个 stack 来存储执行过的命令对象。当调用 executeCommand 方法时，它会执行命令并将其推入栈中；当调用 undoLastCommand 方法时，它会从栈顶弹出命令并执行其 undo 方法。

在 main 函数中，创建了一个 Receiver 对象和一个 ConcreteCommand 对象，并通过 UndoManager 来执行和撤销命令。通过使用 shared_ptr，可以确保 Receiver 和 ConcreteCommand 对象的生命周期得到妥善管理，即使在命令被撤销后也不会导致内存泄漏。

3.2 命令模式应用需要设计一组命令，并且命令之间可以相互组合的场景

在C++中，命令模式可以用于设计一组命令，并允许这些命令之间可以相互组合，形成复合命令。当需要执行一系列操作作为一个单一命令时，这种模式特别有用。如下为样例代码：

#include <iostream>  
#include <memory>  
#include <vector>  

// 命令接口  
class Command {
public:
	virtual ~Command() = default;
	virtual void execute() = 0;
};

// 具体命令类A  
class CommandA : public Command {
public:
	void execute() override {
		std::cout << "Executing CommandA" << std::endl;
	}
};

// 具体命令类B  
class CommandB : public Command {
public:
	void execute() override {
		std::cout << "Executing CommandB" << std::endl;
	}
};

// 复合命令类  
class CompositeCommand : public Command {
public:
	void addCommand(std::shared_ptr<Command> cmd) {
		commands.push_back(cmd);
	}

	void execute() override {
		for (const auto& cmd : commands) {
			cmd->execute();
		}
	}

private:
	std::vector<std::shared_ptr<Command>> commands;
};

int main() 
{
	// 创建具体命令对象  
	auto cmdA = std::make_shared<CommandA>();
	auto cmdB = std::make_shared<CommandB>();

	// 创建复合命令对象  
	auto compositeCmd = std::make_shared<CompositeCommand>();

	// 将具体命令添加到复合命令中  
	compositeCmd->addCommand(cmdA);
	compositeCmd->addCommand(cmdB);

	// 执行复合命令  
	compositeCmd->execute();

	return 0;
}

上面代码的输出为：

Executing CommandA
Executing CommandB

在这个示例中：

Command 是一个抽象基类，定义了命令的接口，即 execute 方法。
CommandA 和 CommandB 是具体命令类，分别实现了 execute 方法以执行特定的操作。
CompositeCommand 是一个复合命令类，它包含一个命令对象的 vector 容器。通过 addCommand 方法，可以将多个具体命令或复合命令添加到复合命令中。当调用 execute 方法时，它会依次执行容器中的每个命令。

在 main 函数中，创建了两个具体命令对象 cmdA 和 cmdB，然后创建了一个复合命令对象 compositeCmd。接着，将 cmdA 和 cmdB 添加到 compositeCmd 中。最后，调用 compositeCmd 的 execute 方法来执行复合命令，这将依次执行 cmdA 和 cmdB。