设计模式（19）-备忘录模式及实现

设计模式（19）-备忘录模式及实现

---

基本概念

通过引入“备忘录”对象，允许在不暴露对象内部结构的情况下，捕获并存储对象的状态。同时，它还提供了一种将对象恢复到之前状态的方式。
优点：
备忘录模式使得对象的状态管理更加灵活。它允许对象在不暴露其内部结构的情况下进行状态的保存和恢复。这有助于实现撤销和重做功能，以及历史记录和快照功能。
缺点：
使用备忘录模式可能会增加一些内存开销，特别是如果需要存储大量的状态历史。

https://gitee.com/want-to-lose-another-30-jin/design-pattern-implementation

设计模式具体实现

---

角色

1、发起人（Originator）：
负责创建一个备忘录，记录当前状态，并可以恢复到先前的状态。

2、备忘录（Memento）：
负责存储发起人的内部状态，并可以防止其他对象对其修改。

3、负责人（Caretaker）：
负责保存备忘录，但不检查备忘录的内容。

java实现

package shejimoshi.beiwanglumoshi;
// 发起人
public class Originator {
    private String state;

    public void setState(String state) {
        this.state = state;
    }

    public String getState() {
        return state;
    }

    public Memento saveStateToMemento() {
        return new Memento(state);
    }

    public void getStateFromMemento(Memento memento) {
        state = memento.getState();
    }
}

package shejimoshi.beiwanglumoshi;
// 备忘录
public class Memento {
    private String state;

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

    public String getState() {
        return state;
    }
}

package shejimoshi.beiwanglumoshi;
// 负责人
public class Caretaker {
    private Memento memento;

    public void setMemento(Memento memento) {
        this.memento = memento;
    }

    public Memento getMemento() {
        return memento;
    }
}

package shejimoshi.beiwanglumoshi;

public class client {
    public static void main(String[] args) {
        Originator originator = new Originator();
        Caretaker caretaker = new Caretaker();

        originator.setState("State #1");
        caretaker.setMemento(originator.saveStateToMemento());

        originator.setState("State #2");
        System.out.println("Current State: " + originator.getState());

        // 恢复到先前的状态
        originator.getStateFromMemento(caretaker.getMemento());
        System.out.println("Restored State: " + originator.getState());
    }
}

c++实现

#include <iostream>
#include <string>

// 备忘录
class Memento {
private:
    std::string state;

public:
    Memento(const std::string& state) : state(state) {}

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

// 发起人
class Originator {
private:
    std::string state;

public:
    void setState(const std::string& state) {
        this->state = state;
    }

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

    Memento* saveStateToMemento() {
        return new Memento(state);
    }

    void getStateFromMemento(Memento* memento) {
        state = memento->getState();
        delete memento; // 释放备忘录对象
    }
};

// 负责人
class Caretaker {
private:
    Memento* memento;

public:
    void setMemento(Memento* memento) {
        this->memento = memento;
    }

    Memento* getMemento() {
        return memento;
    }
};

// 客户端
int main() {
    Originator* originator = new Originator();
    Caretaker* caretaker = new Caretaker();

    originator->setState("State #1");
    caretaker->setMemento(originator->saveStateToMemento());

    originator->setState("State #2");
    std::cout << "Current State: " << originator->getState() << std::endl;

    // 恢复到先前的状态
    originator->getStateFromMemento(caretaker->getMemento());

    std::cout << "Restored State: " << originator->getState() << std::endl;

    delete originator; // 清理发起人对象
    delete caretaker;  // 清理负责人对象

    return 0;
}