命令模式在C++中怎样应用 实现撤销重做功能的典型结构

#include <iostream>
#include <vector>
#include <string>
#include <memory> // For std::unique_ptr
#include <stack>  // For std::stack

// 1. Receiver
class Document {
public:
    void addText(const std::string& text) {
        content_ += text;
        std::cout << "Document: Added '" << text << "'. Current content: " << content_ << std::endl;
    }

    void removeLastText(size_t len) {
        if (content_.length() >= len) {
            content_.resize(content_.length() - len);
            std::cout << "Document: Removed last " << len << " chars. Current content: " << content_ << std::endl;
        } else {
            std::cout << "Document: Cannot remove, content too short." << std::endl;
            content_.clear(); // Or handle error
        }
    }

    const std::string& getContent() const {
        return content_;
    }

private:
    std::string content_ = "";
};

// 2. Command Abstract Base Class
class Command {
public:
    virtual ~Command() = default;
    virtual void execute() = 0;
    virtual void undo() = 0;
};

// 3. ConcreteCommand
class AddTextCommand : public Command {
public:
    AddTextCommand(Document& doc, const std::string& text)
        : document_(doc), textToAdd_(text), previousContentLength_(0) {}

    void execute() override {
        previousContentLength_ = document_.getContent().length(); // Store state for undo
        document_.addText(textToAdd_);
    }

    void undo() override {
        // Simple undo: remove the text we added. This assumes no other changes happened.
        // In a real scenario, you might store the exact text that was there before.
        document_.removeLastText(textToAdd_.length());
    }

private:
    Document& document_;
    std::string textToAdd_;
    size_t previousContentLength_; // To help with undo
};

// 5. CommandHistory (Manager)
class CommandHistory {
public:
    void executeAndPush(std::unique_ptr<Command> cmd) {
        cmd->execute();
        undoStack_.push(std::move(cmd));
        // Any new command clears the redo stack
        while (!redoStack_.empty()) {
            redoStack_.pop();
        }
    }

    bool undo() {
        if (!undoStack_.empty()) {
            std::unique_ptr<Command> cmd = std::move(undoStack_.top());
            undoStack_.pop();
            cmd->undo();
            redoStack_.push(std::move(cmd));
            return true;
        }
        std::cout << "Nothing to undo." << std::endl;
        return false;
    }

    bool redo() {
        if (!redoStack_.empty()) {
            std::unique_ptr<Command> cmd = std::move(redoStack_.top());
            redoStack_.pop();
            cmd->execute(); // Re-execute
            undoStack_.push(std::move(cmd));
            return true;
        }
        std::cout << "Nothing to redo." << std::endl;
        return false;
    }

private:
    std::stack<std::unique_ptr<Command>> undoStack_;
    std::stack<std::unique_ptr<Command>> redoStack_;
};

// 4. Invoker (Example Usage)
int main() {
    Document myDoc;
    CommandHistory history;

    std::cout << "--- Initial State ---" << std::endl;
    history.executeAndPush(std::make_unique<AddTextCommand>(myDoc, "Hello, "));
    history.executeAndPush(std::make_unique<AddTextCommand>(myDoc, "World!"));
    history.executeAndPush(std::make_unique<AddTextCommand>(myDoc, " How are you?"));
    std::cout << "Current Document: " << myDoc.getContent() << std::endl;

    std::cout << "\n--- Undo Operations ---" << std::endl;
    history.undo();
    std::cout << "Current Document: " << myDoc.getContent() << std::endl;
    history.undo();
    std::cout << "Current Document: " << myDoc.getContent() << std::endl;

    std::cout << "\n--- Redo Operations ---" << std::endl;
    history.redo();
    std::cout << "Current Document: " << myDoc.getContent() << std::endl;
    history.redo();
    std::cout << "Current Document: " << myDoc.getContent() << std::endl;

    std::cout << "\n--- New Command After Undo ---" << std::endl;
    history.executeAndPush(std::make_unique<AddTextCommand>(myDoc, " New ending."));
    std::cout << "Current Document: " << myDoc.getContent() << std::endl;

    std::cout << "\n--- Try Redo (Should Fail) ---" << std::endl;
    history.redo(); // Redo stack should be empty now
    std::cout << "Current Document: " << myDoc.getContent() << std::endl;

    return 0;
}