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

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

C++命令模式实现撤销和重做，核心在于将操作封装成对象，并维护一个命令历史栈。通过这种方式，我们可以记录执行过的操作，并在需要时反向执行这些操作。

解决方案

命令模式的关键组成部分包括：

1. Command

   抽象类/接口：定义了执行操作的接口

   execute()

   ，以及撤销操作的接口

   undo()

   。

2. ConcreteCommand

   具体命令类：实现

   Command

   接口，持有接收者（Receiver）的引用，并在

   execute()

   方法中调用接收者的具体操作。

   undo()

   方法则执行相反的操作。

3. Receiver

   接收者：知道如何执行与命令相关的操作。

4. Invoker

   调用者：持有

   Command

   对象，并在适当的时候调用

   execute()

   方法。

5. CommandHistory

   (可选): 用于记录执行过的命令，以便实现撤销和重做功能。

下面是一个简单的 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()

方法可能抛出的异常，并进行处理。在实际应用中，异常处理可能需要更复杂的逻辑，例如记录日志、通知用户等。

以上就是C++命令模式实现撤销和重做功能的详细内容，更多请关注知识资源分享宝库其它相关文章！