备忘录模式是一种行为型设计模式，用于在不破坏封装性的前提下捕获一个对象的内部状态，并在该对象之外保存这个状态，以便之后可以将该对象恢复到之前的状态。这种模式通常用于需要记录对象状态历史、撤销操作或实现“回到过去”功能的场景。
在备忘录模式中，主要有三种角色：
① 备忘录（Memento）：负责存储原发器（Originator）对象的内部状态。备忘录可以根据原发器提供的接口，获取状态或者恢复状态。
② 原发器（Originator）：负责创建备忘录，并记录当前内部状态到备忘录中，或者从备忘录中恢复状态。
③ 管理者（Caretaker）：负责保存备忘录对象，但是不能对备忘录的内容进行操作或者检查。
备忘录模式可以让对象在不暴露其实现细节的情况下，保存和恢复其内部状态，从而提供了更好的封装性和灵活性。

1、场景设计

实现场景：设计备忘录、原发器、管理者，操作一个字符串的备忘与恢复。

2、C++实现

`Memento` 类代表备忘录，`Originator` 类是原发器，负责创建备忘录和恢复状态，`Caretaker` 类是管理者，负责保存备忘录。在 `main` 函数中，我们演示了如何使用备忘录模式来保存对象的状态，并在需要时恢复到之前的状态。 

#include <iostream>
#include <string>

// 备忘录类
class Memento {
    private:
        std::string state;
    public:
        Memento(){}
        Memento(const std::string& s) : state(s) {}
        std::string getState() const {
            return state;
        }
};

// 原发器类
class Originator {
    private:
        std::string state;

    public:
        void setState(const std::string& s) {
            state = s;
        }

        std::string getState() const {
            return state;
        }

        Memento createMemento() {
            return Memento(state);
        }

        void restoreFromMemento(const Memento& m) {
            state = m.getState();
        }
};

// 管理者类
class Caretaker {
    private:
        Memento memento;

    public:
        void saveMemento(const Memento& m) {
            memento = m;
        }

        Memento retrieveMemento() const {
            return memento;
        }
};

int main() {
    Originator originator;
    Caretaker caretaker;

    // 设置初始状态
    originator.setState("State 1");
    std::cout << "Current state: " << originator.getState() << std::endl;

    // 创建备忘录并保存
    caretaker.saveMemento(originator.createMemento());

    // 修改状态
    originator.setState("State 2");
    std::cout << "Current state: " << originator.getState() << std::endl;

    // 恢复到之前的状态
    originator.restoreFromMemento(caretaker.retrieveMemento());
    std::cout << "Restored state: " << originator.getState() << std::endl;

    return 0;
}

3、Java实现

package behavioralpattern.memento;
// 备忘录类
class Memento {
    private final String state;

    public Memento(String state) {
        this.state = state;
    }
    public String getState() {
        return state;
    }
}

// 原发器类
class Originator {
    private String state;
    public void setState(String state) {
        this.state = state;
    }
    public String getState() {
        return state;
    }
    public Memento createMemento() {
        return new Memento(state);
    }
    public void restoreFromMemento(Memento memento) {
        state = memento.getState();
    }
}

// 管理者类
class Caretaker {
    private Memento memento;
    public void saveMemento(Memento memento) {
        this.memento = memento;
    }
    public Memento retrieveMemento() {
        return memento;
    }
}

public class MementoDemo {
    public static void main(String[] args) {
        Originator originator = new Originator();
        Caretaker caretaker = new Caretaker();
        // 设置初始状态
        originator.setState("State 1");
        System.out.println("Current state: " + originator.getState());
        // 创建备忘录并保存
        caretaker.saveMemento(originator.createMemento());
        // 修改状态
        originator.setState("State 2");
        System.out.println("Current state: " + originator.getState());
        // 恢复到之前的状态
        originator.restoreFromMemento(caretaker.retrieveMemento());
        System.out.println("Restored state: " + originator.getState());
    }
}

`Memento` 类代表备忘录，`Originator` 类是原发器，负责创建备忘录和恢复状态，`Caretaker` 类是管理者，负责保存备忘录。在 `main` 方法中，我们演示了如何使用备忘录模式来保存对象的状态，并在需要时恢复到之前的状态。