怎样用C++实现备忘录模式 对象状态保存与恢复的实现

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

// 1. Memento (备忘录) 类
// 存储 Originator 的内部状态。通常，它只提供给 Originator 访问其状态的接口，
// 而对 Caretaker 而言，它是一个不透明的对象。
class Memento {
private:
    std::string state_; // 存储的具体状态数据

    // 允许 Originator 访问 Memento 的私有状态
    friend class Originator;

    // 私有构造函数，确保只有 Originator 能创建 Memento
    Memento(const std::string& state) : state_(state) {
        // std::cout << "Memento created with state: " << state_ << std::endl;
    }

public:
    // Caretaker 可以通过这个接口获取 Memento 的一些元信息，
    // 但不能直接修改其内部状态
    std::string GetName() const {
        // 实际应用中可能返回时间戳或版本号
        return "State_" + state_.substr(0, 5) + "...";
    }

    // 析构函数，如果内部有动态资源需要释放
    ~Memento() {
        // std::cout << "Memento for state '" << state_ << "' destroyed." << std::endl;
    }
};

// 2. Originator (发起人) 类
// 拥有一个需要被保存和恢复状态的对象。
// 它负责创建 Memento 并使用 Memento 恢复其内部状态。
class Originator {
private:
    std::string state_; // Originator 的当前状态

public:
    Originator(const std::string& state) : state_(state) {
        std::cout << "Originator: Initializing with state: " << state_ << std::endl;
    }

    void DoSomething() {
        // 模拟 Originator 进行一些操作，改变自身状态
        static int counter = 0;
        state_ = "State_" + std::to_string(counter++) + "_doing_something_important";
        std::cout << "Originator: Changed state to: " << state_ << std::endl;
    }

    // 创建一个 Memento 来保存当前状态
    std::shared_ptr<Memento> Save() {
        std::cout << "Originator: Saving current state to Memento." << std::endl;
        return std::make_shared<Memento>(state_);
    }

    // 从 Memento 恢复状态
    void Restore(std::shared_ptr<Memento> memento) {
        if (memento) {
            state_ = memento->state_; // 直接访问 Memento 的私有状态
            std::cout << "Originator: Restoring state to: " << state_ << std::endl;
        } else {
            std::cout << "Originator: Cannot restore from a null Memento." << std::endl;
        }
    }

    void ShowState() const {
        std::cout << "Originator: Current state is: " << state_ << std::endl;
    }
};

// 3. Caretaker (负责人) 类
// 负责保存 Memento 对象，但从不检查或修改 Memento 的内容。
// 它只知道 Memento 是一个可以被保存和检索的对象。
class Caretaker {
private:
    std::vector<std::shared_ptr<Memento>> mementos_; // 存储 Memento 对象的集合
    std::shared_ptr<Originator> originator_;         // 持有 Originator 的引用

public:
    Caretaker(std::shared_ptr<Originator> originator) : originator_(originator) {}

    void Backup() {
        std::cout << "\nCaretaker: Saving Originator's state..." << std::endl;
        mementos_.push_back(originator_->Save());
    }

    void Undo() {
        if (mementos_.empty()) {
            std::cout << "\nCaretaker: No mementos to restore from." << std::endl;
            return;
        }

        std::shared_ptr<Memento> memento = mementos_.back();
        mementos_.pop_back();
        std::cout << "\nCaretaker: Restoring state to: " << memento->GetName() << std::endl;
        originator_->Restore(memento);
    }

    void ShowHistory() const {
        std::cout << "\nCaretaker: Here's the list of mementos:" << std::endl;
        for (const auto& memento : mementos_) {
            std::cout << " - " << memento->GetName() << std::endl;
        }
    }
};

// 客户端代码示例
int main() {
    auto originator = std::make_shared<Originator>("Initial State");
    auto caretaker = std::make_unique<Caretaker>(originator);

    caretaker->Backup(); // 保存初始状态
    originator->DoSomething();
    originator->ShowState();

    caretaker->Backup(); // 保存新状态
    originator->DoSomething();
    originator->ShowState();

    caretaker->Backup(); // 保存再一个新状态
    originator->DoSomething();
    originator->ShowState();

    caretaker->ShowHistory();

    std::cout << "\n--- Performing Undo operations ---" << std::endl;
    caretaker->Undo(); // 恢复到上一个状态
    originator->ShowState();

    caretaker->Undo(); // 恢复到再上一个状态
    originator->ShowState();

    caretaker->Undo(); // 恢复到初始状态
    originator->ShowState();

    caretaker->Undo(); // 尝试恢复，但没有更多备忘录了

    return 0;
}