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++ 示例：

立即学习“C++免费学习笔记（深入）”；

#include 
#include 
#include 

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

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

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

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

先锋多用户商城系统

修改自网上仿乐购商城，新增功能：1、数据库在线备份与导入功能，可以随时备份数据库，数据受损可以导入数据库，确保数据安全；2、增加组合商品概念，可以用于组配商品销售（比如外套有蓝色和红色，鞋子有40码和41码等），买一送一、组合销售（比如上衣＋围巾＋长裙做为一个套装商品）和加价购买等销售方式；3、按照商品重量和送货距离实时计算精确运费，并可在订单中予以显示，使运费金额实现实时动态准确显示、清晰明了；

下载

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()