C++ 设计模式之备忘录模式

设计模式之备忘录模式

备忘录，在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态。该模式很好理解，其UML图如下：

　　在Originator中提供了创建Memento的接口，具体要保存什么样的内容，则根据需求来定。而Caretaker则是负责管理Memento。而保存的内容的具体的组织方式什么的都封装在Memento中了。这样做耦合性很低，方便维护和扩展。示例代码如下：

 1 // MemoModel.h文件
 2 #pragma once
 3 #include <iostream>
 4 #include <string>
 5 
 6 class Memo;
 7 
 8 class Originator
 9 {
10 private:
11     std::string m_state;
12 public:
13     Memo * createMemo();
14     void show()
15     {
16         std::cout << m_state << std::endl;
17     }
18     void setState(std::string str)
19     {
20         m_state = str;
21     }
22     void recoverState(Memo * p);
23 };
24 
25 class Memo
26 {
27 public:
28     std::string m_state;
29     Memo(std::string str)
30     {
31         m_state = str;
32     }
33 
34 };
35 
36 Memo * Originator::createMemo()
37 {
38     return new Memo(m_state);
39 }
40 
41 void Originator::recoverState(Memo * p)
42 {
43     setState(p->m_state);
44 }
45 
46 class Caretaker
47 {
48 private:
49     Memo * m_pMemo;
50 public:
51     Caretaker() : m_pMemo(nullptr) {}
52     ~Caretaker()
53     {
54         if (nullptr != m_pMemo)
55             delete m_pMemo;
56     }
57     Memo * getMemo()
58     {
59         return m_pMemo;
60     }
61     void setMemo(Memo * p)
62     {
63         m_pMemo = p;
64     }
65 };

测试代码如下：

 1 #include <iostream>
 2 #include "MemoModel.h"
 3 
 4 int main()
 5 {
 6     using namespace std;
 7     // 备忘录模式
 8     Originator * p = new Originator;
 9     Caretaker * pCare = new Caretaker;
10     // 设置状态
11     p->setState("A");
12     p->show();
13     // 创建备忘录
14     pCare->setMemo(p->createMemo());
15     // 更改状态
16     p->setState("B");
17     p->show();
18     // 恢复状态
19     p->recoverState(pCare->getMemo());
20     p->show();
21     delete pCare;
22     delete p;
23 
24     getchar();
25     return 0;
26 }

测试结果如下图：

　　备忘录模式把要保存的细节封装在了Memo类中，如果要修改保存细节的话，不会影响到客户端。备忘录模式比较适用于功能比较复杂的，但需要维护或记录属性历史的类，或者需要保存的属性只是众多属性中的一小部分时。