23种设计模式 3 行为型模式 之3.5 memento 备忘录/快照模式

参考1 网友k_eckel 的书籍《设计模式精讲-GoF 23种设计模式解析附C++实现源码》

参考2 腾讯元宝问答

参考3 github copilot问答

文章目录

• [0 前言](#0 前言)
• [1 问题](#1 问题)
• [2 模式选择](#2 模式选择)
• [3 实现](#3 实现)
• • [3.1 memento.h](#3.1 memento.h)
  • [3.2 memento.cpp](#3.2 memento.cpp)
  • [3.3 main.cp](#3.3 main.cp)
  • [3.4 原作者对代码说明](#3.4 原作者对代码说明)
• [4 讨论](#4 讨论)
• [5 总结](#5 总结)

---

0 前言

memento 模式，备忘录模式/快照模式。

实现操做的撤销功能。

1 问题

没有人想犯错，但没有人能够不犯错。犯错了一般只能改过，却很难改正（恢复）。

在软件系统的设计时，要给用户后悔的权力，一些操做，肯定需要提供诸如撤销（Undo）操做。

memento 模式就是为了提供撤销操做。

2 模式选择

memento模式的关键就是，不破化封装行的前提下，捕获并保存一个类的内部状态，这样就可以利用该保存的状态试试恢复操做。

（为了达到这个目标，可以在后面的实现中看到我们采取了一定语言支持的技术。）

3 实现

3.1 memento.h

#ifndef __MEMENTO_H_
#define __MEMENTO_H_

#include <string>
using namespace std;

class memento;

class originator
{
public:
        typedef string state;
        originator();
        originator(const state& sdt);
        ~originator();
        memento* create_memento();
        void set_memento(memento* men);
        void restore_to_memento(memento* mt);
        state get_state();
        void set_state(const state& sdt);
        void print_state();
protected:

private:
        state _sdt;
        memento* _mt;

};

class memento
{
public:

protected:

private:
//这里最关键的地方，将originator 为 friend类， 可以访问内部信息，但是其他类不能访问
        friend class originator;
        typedef string state;
        memento();
        memento(const state& sdt);
        ~memento();
        void set_state(const state& sdt);
        state get_state();
private:
        state _sdt;
};

#endif //~~ __MEMENTO_H_

3.2 memento.cpp

#include "memento.h"
#include <iostream>

using namespace std;
typedef string state;

originator::originator()
{
        _sdt = "";
        _mt = 0;

}

originator::originator(const state& sdt)
{
        _sdt = "";
        _mt = 0;

}

originator::~originator()
{

}

memento* originator::create_memento()
{
        return new memento(_sdt);
}

state originator::get_state()
{
        return _sdt;
}

void originator::set_state(const state& sdt)
{
        _sdt = sdt;
}

void originator::print_state()
{
        cout << this-> _sdt << "......" << endl;
}

void originator::set_memento(memento* men)
{

}

void originator::restore_to_memento(memento* mt)
{
        this->_sdt = mt->get_state();
}

//class memento
memento::memento()
{

}

memento::memento(const state& sdt)
{
        _sdt = sdt;
}

state memento::get_state()
{
        return _sdt;
}

void memento::set_state(const state& sdt)
{
        _sdt = sdt;
}

3.3 main.cp

#include "memento.h"
#include <iostream>

using namespace std;

int main(int argc, char* argv[])
{
        originator* o = new originator();
        o->set_state("old");//被往前状态
        o->print_state();

        memento* m = o->create_memento();//将状态备忘
        o->set_state("new");//修改状态
        o->print_state();
        o->restore_to_memento(m);
        o->print_state();

        return 0;
}

运行结果

3.4 原作者对代码说明

4 讨论

原作者内容

5 总结

memento模式（备忘录模式）解决的问题：用户的撤销操做；

这里实现的方式：

memento和originator 相互包含共同的可撤销元素；

memento的friend class来保证mement封装性。

originator

提供方法来生成快照memento来保存originator状态；

提供方法来还原memento状态到originator