答案：C++命令模式通过封装操作为对象并维护命令历史栈实现撤销重做，核心组件包括Command接口、具体命令类、接收者、调用者和命令历史栈。具体命令类保存执行前后状态以支持undo，复杂参数可通过成员变量封装，执行失败时可在execute中捕获异常并尝试恢复状态，与状态模式不同，命令模式关注操作的封装与执行控制。
C++命令模式实现撤销和重做，核心在于将操作封装成对象，并维护一个命令历史栈。通过这种方式，我们可以记录执行过的操作，并在需要时反向执行这些操作。
解决方案
命令模式的关键组成部分包括：
Command
抽象类/接口：定义了执行操作的接口execute()
，以及撤销操作的接口undo()
。ConcreteCommand
具体命令类：实现Command
接口，持有接收者（Receiver）的引用，并在execute()
方法中调用接收者的具体操作。undo()
方法则执行相反的操作。Receiver
接收者：知道如何执行与命令相关的操作。Invoker
调用者：持有Command
对象，并在适当的时候调用execute()
方法。CommandHistory
(可选): 用于记录执行过的命令，以便实现撤销和重做功能。
下面是一个简单的 C++ 示例：
立即学习“C++免费学习笔记（深入）”；
#include <iostream>
#include <vector>
#include <stack>
// Receiver
class Light {
public:
void turnOn() {
std::cout << "Light is on" << std::endl;
isOn = true;
}
void turnOff() {
std::cout << "Light is off" << std::endl;
isOn = false;
}
bool isOn = false;
};
// Command interface
class Command {
public:
virtual void execute() = 0;
virtual void undo() = 0;
virtual ~Command() {}
};
// Concrete Commands
class TurnOnCommand : public Command {
public:
TurnOnCommand(Light* light) : light_(light) {}
void execute() override {
light_->turnOn();
}
void undo() override {
light_->turnOff();
}
private:
Light* light_;
};
class TurnOffCommand : public Command {
public:
TurnOffCommand(Light* light) : light_(light) {}
void execute() override {
light_->turnOff();
}
void undo() override {
light_->turnOn();
}
private:
Light* light_;
};
// Invoker
class RemoteControl {
public:
void setCommand(Command* command) {
command_ = command;
}
void pressButton() {
if (command_) {
command_->execute();
history_.push(command_);
}
}
void undo() {
if (!history_.empty()) {
Command* command = history_.top();
history_.pop();
command->undo();
}
}
private:
Command* command_ = nullptr;
std::stack<Command*> history_;
};
int main() {
Light light;
TurnOnCommand turnOn(&light);
TurnOffCommand turnOff(&light);
RemoteControl remote;
remote.setCommand(&turnOn);
remote.pressButton(); // Light is on
remote.setCommand(&turnOff);
remote.pressButton(); // Light is off
remote.undo(); // Light is on
remote.undo(); // Light is off
return 0;
}如何处理复杂的命令参数？
对于复杂的命令，参数的处理是个挑战。可以将参数封装到命令对象中，或者使用一个专门的参数对象。
例如，假设我们需要一个可以改变灯光亮度的命令。我们可以这样做：
class ChangeBrightnessCommand : public Command {
public:
ChangeBrightnessCommand(Light* light, int newBrightness) : light_(light), newBrightness_(newBrightness) {}
void execute() override {
previousBrightness_ = light_->brightness;
light_->brightness = newBrightness_;
std::cout << "Brightness changed to " << newBrightness_ << std::endl;
}
void undo() override {
light_->brightness = previousBrightness_;
std::cout << "Brightness changed back to " << previousBrightness_ << std::endl;
}
private:
Light* light_;
int newBrightness_;
int previousBrightness_;
};
// Light 类需要增加 brightness 属性
class Light {
public:
Light() : brightness(50) {}
void turnOn() {
std::cout << "Light is on, brightness: " << brightness << std::endl;
isOn = true;
}
void turnOff() {
std::cout << "Light is off" << std::endl;
isOn = false;
}
bool isOn = false;
int brightness;
};关键在于
ChangeBrightnessCommand保存了修改前后的亮度值，以便
undo()方法能够正确恢复。
命令模式与状态模式的区别是什么？
虽然命令模式和状态模式都涉及状态的改变，但它们的目的和实现方式有所不同。命令模式将操作封装成对象，用于请求的排队、记录请求日志、支持可撤销的操作等。它关注的是做什么。状态模式则允许对象在内部状态改变时改变它的行为，好像修改了它的类。它关注的是如何做。
简而言之，命令模式侧重于操作的封装和控制，而状态模式侧重于对象行为的改变。状态模式通常会改变对象的状态，而命令模式则可能或可能不改变接收者的状态。
如何处理命令执行失败的情况？
处理命令执行失败的情况需要仔细考虑。一种方法是在
execute()方法中捕获异常，并在
undo()方法中尝试恢复到之前的状态。另一种方法是在执行命令之前进行验证，确保命令可以成功执行。
例如：
class SafeTurnOnCommand : public Command {
public:
SafeTurnOnCommand(Light* light) : light_(light) {}
void execute() override {
if (light_->isOn) {
std::cout << "Light is already on" << std::endl;
return;
}
try {
light_->turnOn();
} catch (const std::exception& e) {
std::cerr << "Error turning on the light: " << e.what() << std::endl;
// 尝试恢复到之前的状态 (如果可能)
// 例如，如果 turnOn 改变了其他状态，需要在这里撤销
}
}
void undo() override {
if (light_->isOn) {
light_->turnOff();
}
}
private:
Light* light_;
};这个例子中，
SafeTurnOnCommand首先检查灯是否已经打开，避免重复操作。同时，它捕获
turnOn()方法可能抛出的异常，并进行处理。在实际应用中，异常处理可能需要更复杂的逻辑，例如记录日志、通知用户等。
