怎样实现C++的命令模式 请求封装与撤销操作支持

#include <iostream>
#include <vector>
#include <string>
#include <memory> // For std::shared_ptr
#include <stack>  // For undo/redo history

// 1. 抽象命令接口 (ICommand)
class ICommand {
public:
    virtual ~ICommand() = default;
    virtual void execute() = 0;
    virtual void undo() = 0; // 支持撤销
};

// 2. 接收者 (Receiver) - 实际执行操作的对象
class Light {
private:
    std::string location;
    bool isOn = false;
public:
    Light(const std::string& loc) : location(loc) {}

    void on() {
        if (!isOn) {
            std::cout << location << "灯亮了。" << std::endl;
            isOn = true;
        }
    }

    void off() {
        if (isOn) {
            std::cout << location << "灯灭了。" << std::endl;
            isOn = false;
        }
    }

    bool getIsOn() const { return isOn; }
};

// 3. 具体命令 (Concrete Commands)
class LightOnCommand : public ICommand {
private:
    Light& light;
    bool previousState; // 记录执行前的状态，用于撤销
public:
    LightOnCommand(Light& l) : light(l), previousState(l.getIsOn()) {}

    void execute() override {
        previousState = light.getIsOn(); // 确保记录的是当前状态
        light.on();
    }

    void undo() override {
        if (previousState) { // 如果之前是亮的，撤销就是让它亮
            light.on();
        } else { // 如果之前是灭的，撤销就是让它灭
            light.off();
        }
        std::cout << "撤销：将" << (previousState ? "亮" : "灭") << "状态恢复。" << std::endl;
    }
};

class LightOffCommand : public ICommand {
private:
    Light& light;
    bool previousState; // 记录执行前的状态，用于撤销
public:
    LightOffCommand(Light& l) : light(l), previousState(l.getIsOn()) {}

    void execute() override {
        previousState = light.getIsOn(); // 确保记录的是当前状态
        light.off();
    }

    void undo() override {
        if (previousState) { // 如果之前是亮的，撤销就是让它亮
            light.on();
        } else { // 如果之前是灭的，撤销就是让它灭
            light.off();
        }
        std::cout << "撤销：将" << (previousState ? "亮" : "灭") << "状态恢复。" << std::endl;
    }
};

// 4. 调用者 (Invoker) - 持有命令并触发执行
class RemoteControl {
private:
    std::stack<std::shared_ptr<ICommand>> history; // 已执行的命令历史
    std::stack<std::shared_ptr<ICommand>> redoHistory; // 撤销后的命令历史
public:
    void setCommand(std::shared_ptr<ICommand> command) {
        // 在这里，我们通常会直接执行，或者添加到队列中
        // 为了演示，我们直接执行并添加到历史
        command->execute();
        history.push(command);
        // 执行新命令后，清空redo历史，因为新的操作会覆盖之前的redo点
        while (!redoHistory.empty()) {
            redoHistory.pop();
        }
    }

    void undoLastCommand() {
        if (!history.empty()) {
            std::shared_ptr<ICommand> lastCommand = history.top();
            history.pop();
            lastCommand->undo();
            redoHistory.push(lastCommand); // 将撤销的命令放入redo历史
        } else {
            std::cout << "没有更多可撤销的操作了。" << std::endl;
        }
    }

    void redoLastUndo() {
        if (!redoHistory.empty()) {
            std::shared_ptr<ICommand> lastRedoCommand = redoHistory.top();
            redoHistory.pop();
            lastRedoCommand->execute(); // 重做就是再次执行
            history.push(lastRedoCommand); // 将重做的命令放回历史
        } else {
            std::cout << "没有更多可重做的操作了。" << std::endl;
        }
    }
};

// 客户端代码 (Client)
// int main() {
//     Light livingRoomLight("客厅");
//     Light kitchenLight("厨房");

//     std::shared_ptr<ICommand> livingRoomLightOn = std::make_shared<LightOnCommand>(livingRoomLight);
//     std::shared_ptr<ICommand> livingRoomLightOff = std::make_shared<LightOffCommand>(livingRoomLight);
//     std::shared_ptr<ICommand> kitchenLightOn = std::make_shared<LightOnCommand>(kitchenLight);
//     std::shared_ptr<ICommand> kitchenLightOff = std::make_shared<LightOffCommand>(kitchenLight);

//     RemoteControl remote;

//     // 执行操作
//     remote.setCommand(livingRoomLightOn);
//     remote.setCommand(kitchenLightOn);
//     remote.setCommand(livingRoomLightOff);

//     std::cout << "\n--- 尝试撤销 ---\n";
//     remote.undoLastCommand(); // 撤销客厅灯灭 -> 客厅灯亮
//     remote.undoLastCommand(); // 撤销厨房灯亮 -> 厨房灯灭
//     remote.undoLastCommand(); // 撤销客厅灯亮 -> 客厅灯灭
//     remote.undoLastCommand(); // 没有更多可撤销的了

//     std::cout << "\n--- 尝试重做 ---\n";
//     remote.redoLastUndo(); // 重做客厅灯亮
//     remote.redoLastUndo(); // 重做厨房灯亮
//     remote.redoLastUndo(); // 重做客厅灯灭
//     remote.redoLastUndo(); // 没有更多可重做的了

//     std::cout << "\n--- 新操作会清除重做历史 ---\n";
//     remote.setCommand(kitchenLightOff); // 厨房灯灭
//     remote.redoLastUndo(); // 此时重做历史已被清空

//     return 0;
// }

ICommand

execute()

Command

Receiver

Invoker

execute()

LightOnCommand

on()

undo()

history

undoStack

redoHistory

redoStack

MacroCommand

ICommand

ICommand

MacroCommand

new

CommandFactory

ICommand

execute()