C++命令模式实现撤销和重做功能-C++-PHP中文网

C++命令模式实现撤销和重做功能

P粉602998670

发布： 2025-09-02 08:42:01

原创

558人浏览过

答案：C++命令模式通过封装操作为对象并维护命令历史栈实现撤销重做，核心组件包括Command接口、具体命令类、接收者、调用者和命令历史栈。具体命令类保存执行前后状态以支持undo，复杂参数可通过成员变量封装，执行失败时可在execute中捕获异常并尝试恢复状态，与状态模式不同，命令模式关注操作的封装与执行控制。

c++命令模式实现撤销和重做功能

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;
}

登录后复制

如何处理复杂的命令参数？

对于复杂的命令，参数的处理是个挑战。可以将参数封装到命令对象中，或者使用一个专门的参数对象。

例如，假设我们需要一个可以改变灯光亮度的命令。我们可以这样做：

降重鸟

要想效果好，就用降重鸟。AI改写智能降低AIGC率和重复率。

113

查看详情

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_;
};

登录后复制

这个例子中，