备忘录模式（Memento Pattern）

定义

备忘录模式（Memento Pattern）是一种行为设计模式，它允许在不破坏封装性的前提下捕获一个对象的内部状态，并在以后将对象恢复到该状态。备忘录模式通常用于实现撤销操作（Undo）或历史记录（History）等功能。

在备忘录模式中，我们定义三个角色：

Originator：记录当前时刻它的内部状态，并可使用备忘录对象恢复到之前的状态。
Memento：负责存储Originator对象的内部状态，并可防止Originator以外的对象访问备忘录。
Caretaker：负责保存好备忘录对象，不能对备忘录的内容进行操作或检查。

示例

下面是一个C++的备忘录模式示例：

cpp 复制代码

#include <iostream>  
#include <string>  
#include <vector>  
  
// Memento类，存储Originator的内部状态  
class Memento {  
public:  
    std::string state; // 假设Originator有一个string类型的状态  
  
    // 构造函数，用于从Originator获取状态  
    Memento(const std::string& state) : state(state) {}  
};  
  
// Originator类，负责创建Memento，并可以使用Memento恢复状态  
class Originator {  
private:  
    std::string state; // Originator的内部状态  
  
public:  
    // 获取当前状态  
    std::string getState() const {  
        return state;  
    }  
  
    // 设置状态  
    void setState(const std::string& newState) {  
        state = newState;  
        std::cout << "Originator state changed to: " << state << std::endl;  
    }  
  
    // 创建Memento对象，保存当前状态  
    Memento* createMemento() {  
        return new Memento(state);  
    }  
  
    // 使用Memento恢复状态  
    void restoreMemento(const Memento* memento) {  
        state = memento->state;  
        std::cout << "Originator state restored to: " << state << std::endl;  
    }  
};  
  
// Caretaker类，负责保存Memento对象  
class Caretaker {  
private:  
    std::vector<Memento*> mementos; // 存储Memento对象的容器  
  
public:  
    // 添加Memento到容器中  
    void addMemento(Memento* memento) {  
        mementos.push_back(memento);  
    }  
  
    // 获取Memento对象，用于恢复状态  
    Memento* getMemento(int index) {  
        if (index >= 0 && index < mementos.size()) {  
            return mementos[index];  
        }  
        return nullptr;  
    }  
};  
  
int main() {  
    Originator* originator = new Originator();  
    Caretaker* caretaker = new Caretaker();  
  
    // 设置Originator的初始状态  
    originator->setState("Initial State");  
  
    // 保存当前状态到Caretaker  
    caretaker->addMemento(originator->createMemento());  
  
    // 修改Originator的状态  
    originator->setState("Modified State");  
  
    // 使用Caretaker中的Memento恢复Originator的状态  
    originator->restoreMemento(caretaker->getMemento(0));  
  
    // 清理资源  
    delete originator;  
    delete caretaker;  
  
    return 0;  
}

在这个示例中：

Memento 类存储了 Originator 的内部状态，即一个字符串 state。
Originator 类有一个私有成员 state，并提供了 setState 和 getState 方法来修改和获取这个状态。它还提供了 createMemento 方法来创建一个包含当前状态的 Memento 对象，以及 restoreMemento 方法来根据 Memento 对象恢复状态。
Caretaker 类负责保存 Memento 对象，并提供 addMemento 和 getMemento 方法来添加和获取 Memento 对象。

在 main 函数中，我们创建了一个 Originator 对象和一个 Caretaker 对象。我们首先设置了 Originator 的初始状态，并将这个状态保存到 Caretaker 中。然后我们修改了 Originator 的状态，并使用 Caretaker 中保存的 Memento 对象来恢复 Originator 的状态。

这个示例展示了如何使用备忘录模式来保存和恢复对象的状态。在实际应用中，备忘录模式常用于实现撤销操作、历史记录、事务处理等需要保存和恢复对象状态的功能。