备忘录模式

1 备忘录模式

在GOF的《设计模式:可复用面向对象软件的基础》一书中对备忘录模式是这样说的：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态。

有时有必要记录一个对象的内部状态。为了允许用户取消不确定的操作或从错误中恢复过来，需要实现检查点和取消机制，而要实现这些机制，你必须事先将状态信息保存在某处，这样才能将对象恢复到它们先前的状态。如何实现这个将状态信息保存在某处呢？使用原型模式？由于对象通常封装了其部分或所有的状态信息，使得其状态不能被其他对象访问，也就不可能在该对象之外保存其状态了。由于原型模式总是返回对象的全部状态信息，同时原型模式使其状态能被其它对象访问，这样就违反了封装的原则，还可能有损应用的可靠性和可扩展性。

再拿上面的《仙剑奇侠传》进行分析，当我们在打大BOSS之前存档，此时就需要将对应的游戏场景，任务信息，人物信息等等状态存储起来；当赢得大BOSS之后，覆盖之前的存档时，就将之前的存档丢弃，新建立一个存档，保存当前的状态信息；如果打输了，恢复存档，就将之前的存档信息读取出来，还原到打大BOSS之前的游戏场景，重新开始打大BOSS。这里面就是使用的备忘录模式。

一个备忘录是一个对象，它存储另一个对象在某个瞬间的内部状态，而后者称为备忘录的原发器。当需要设置原发器的检查点时，取消操作机制会向原发器请求一个备忘录。原发器用描述当前状态的信息初始化该备忘录。只有原发器可以向备忘录中存取信息，备忘录对其他的对象是“不可见”的。

2 UML类图

Memento：备忘录存储原发器对象的内部状态。原发器根据需要决定备忘录存储原发器的哪些内部状态；防止原发器以外的其他对象访问备忘录。备忘录实际上有两个接口，管理者只能看到备忘录的窄接口————它只能将备忘录传递给其他对象。相反，原发器能够看到一个宽接口，允许它访问返回到先前状态所需的所有数据。理想的情况是只允许生成备忘录的那个原发器访问本备忘录的内部状态；

Originator：原发器创建一个备忘录，用以记录当前时刻它的内部状态；我们使用备忘录恢复内部状态；

Caretaker：负责保存好备忘录；但是，不能对备忘录的内容进行操作或检查。

备忘录模式是按照以下方式进行协作的：

管理器向原发器请求一个备忘录，保留一段时间后，将其送回给原发器；而有的时候管理者不会将备忘录返回给原发器，因为原发器可能根本不需要退到先前的状态。备忘录是被动的，只有创建备忘录的原发器会对它的状态进行赋值和检索，如下面的时序图：

3 使用场合

在以下情况下使用备忘录模式：

必须保存一个对象在某一个时刻的部分或完整状态，这样以后需要时它才能恢复到先前的状态；

如果一个用接口来让其它对象直接得到这些状态，将会暴露对象的实现细节并破坏对象的封装性。

4 代码实现

// wcscpy_s不能在线编译包含string.h、wchar.h也不行，VC也不行！

复制代码
  1 #include <iostream>
  2 using namespace std;
  3 
  4 struct State
  5 {
  6      wchar_t wcsState[260];
  7 };
  8 
  9 class Memento
 10 {
 11 public:
 12      Memento(State *pState) : m_pState(pState){}
 13 
 14      State *GetState() { return m_pState; }
 15 
 16 private:
 17      friend class Originator;
 18 
 19      State *m_pState;
 20 };
 21 
 22 class Originator
 23 {
 24 public:
 25      Originator() : m_pState(NULL) {}
 26      ~Originator()
 27      {
 28           // Delete the storage of the state
 29           if (m_pState)
 30           {
 31                delete m_pState;
 32                m_pState = NULL;
 33           }
 34      }
 35 
 36      void SetMemento(Memento *pMemento);
 37      Memento *CreateMemento();
 38 
 39      void SetValue(wchar_t *value)
 40      {
 41           memset(wcsValue, 0, 260 * sizeof(wchar_t));
 42           wcscpy_s(wcsValue, 260, value);
 43      }
 44 
 45      void PrintState() { wcout<<wcsValue<<endl; }
 46 
 47 private:
 48      State *m_pState; // To store the object's state
 49 
 50      wchar_t wcsValue[260]; // This is the object's real data
 51 };
 52 
 53 Memento *Originator::CreateMemento()
 54 {
 55      m_pState = new State;
 56      if (m_pState == NULL)
 57      {
 58           return NULL;
 59      }
 60 
 61      Memento *pMemento = new Memento(m_pState);
 62 
 63      wcscpy_s(m_pState->wcsState, 260, wcsValue); // Backup the value
 64      return pMemento;
 65 }
 66 
 67 void Originator::SetMemento(Memento *pMemento)
 68 {
 69      m_pState = pMemento->GetState();
 70 
 71      // Recovery the data
 72      memset(wcsValue, 0, 260 * sizeof(wchar_t));
 73      wcscpy_s(wcsValue, 260, m_pState->wcsState);
 74 }
 75 
 76 // Manager the Memento
 77 class Caretaker
 78 {
 79 public:
 80      Memento *GetMemento() { return m_pMemento; }
 81      void SetMemnto(Memento *pMemento)
 82      {
 83           // Free the previous Memento
 84           if (m_pMemento)
 85           {
 86                delete m_pMemento;
 87                m_pMemento = NULL;
 88           }
 89 
 90           // Set the new Memento
 91           m_pMemento = pMemento;
 92      }
 93 
 94 private:
 95      Memento *m_pMemento;
 96 };
 97 
 98 int main()
 99 {
100      Originator *pOriginator = new Originator();
101      pOriginator->SetValue(L"On");
102      pOriginator->PrintState();
103 
104      // Now I backup the state
105      Caretaker *pCaretaker = new Caretaker();
106      pCaretaker->SetMemnto(pOriginator->CreateMemento());
107 
108      // Set the new state
109      pOriginator->SetValue(L"Off");
110      pOriginator->PrintState();
111 
112      // Recovery to the old state
113      pOriginator->SetMemento(pCaretaker->GetMemento());
114      pOriginator->PrintState();
115 
116      if (pCaretaker)
117      {
118           delete pCaretaker;
119      }
120 
121      if (pOriginator)
122      {
123           delete pOriginator;
124      }
125 
126      return 0;
127 }

我再根据上面的《仙剑奇侠传》来完成备忘录模式，代码如下：

复制代码
 1 #include <iostream>
 2 using namespace std;
 3 
 4 class RoleStateMemento
 5 {
 6 public:
 7      RoleStateMemento(unsigned iBlood, unsigned iAttack, unsigned iDefense) 
                         : m_iBlood(iBlood), m_iAttack(iAttack), m_iDefense(iDefense){}
 8 
 9 private:
10      friend class GameRole;
11 
12      unsigned GetBloodValue() { return m_iBlood; }
13      unsigned GetAttackValue() { return m_iAttack; }
14      unsigned GetDefenseValue() { return m_iDefense; }
15 
16      unsigned m_iBlood;   // 生命力
17      unsigned m_iAttack;  // 攻击力
18      unsigned m_iDefense; // 防御力
19 };
20 
21 class GameRole
22 {
23 public:
24      GameRole() : m_iBlood(100), m_iAttack(100), m_iDefense(100){}
25 
26      // 存档
27      RoleStateMemento *SaveState() { return new RoleStateMemento(m_iBlood, 
                    m_iAttack, m_iDefense); }
28 
29      // 恢复存档
30      void RecoveryState(RoleStateMemento *pRoleState)
31      {
32           m_iBlood = pRoleState->GetBloodValue();
33           m_iAttack = pRoleState->GetAttackValue();
34           m_iDefense = pRoleState->GetDefenseValue();
35           cout<<"Recovery..."<<endl;
36      }
37 
38      void ShowState()
39      {
40           cout<<"Blood:"<<m_iBlood<<endl;
41           cout<<"Attack:"<<m_iAttack<<endl;
42           cout<<"Defense:"<<m_iDefense<<endl;
43      }
44 
45      void Fight()
46      {
47           m_iBlood -= 100;
48           m_iAttack -= 10;
49           m_iDefense -= 20;
50 
51           if (m_iBlood == 0)
52           {
53                cout<<"Game Over"<<endl;
54           }
55      }
56 
57 private:
58      unsigned m_iBlood;   // 生命力
59      unsigned m_iAttack;  // 攻击力
60      unsigned m_iDefense; // 防御力
61 };
62 
63 class RoleStateCaretaker
64 {
65 public:
66      void SetRoleStateMemento(RoleStateMemento *pRoleStateMemento) { 
                        m_pRoleStateMemento = pRoleStateMemento; }
67      RoleStateMemento *GetRoleStateMemento() { return m_pRoleStateMemento; }
68 
69 private:
70      RoleStateMemento *m_pRoleStateMemento;
71 };
72 
73 int main()
74 {
75      GameRole *pLiXY = new GameRole(); // 创建李逍遥这个角色
76      pLiXY->ShowState(); // 显示初始的状态
77 
78      // 存档
79      RoleStateCaretaker *pRoleStateCaretaker = new RoleStateCaretaker();
80      pRoleStateCaretaker->SetRoleStateMemento(pLiXY->SaveState());
81 
82      // 开始打大BOSS
83      pLiXY->Fight();
84      pLiXY->ShowState();
85 
86      // 读档，从新开始
87      pLiXY->RecoveryState(pRoleStateCaretaker->GetRoleStateMemento());
88      pLiXY->ShowState();
89 
90      return 0;
91 }

output:

Blood:100      
Attack:100     
Defense:100    
Game Over      
Blood:0        
Attack:90      
Defense:80     
Recovery...    
Blood:100      
Attack:100     
Defense:100

5 总结

备忘录模式在实际应用中也不少；我们在进行文档编辑时，经常使用的撤销操作。使用C++实现备忘录模式的关键点在于Originator类是Memento的友元类，这样就使得管理备忘录的Caretaker对象，以及其它对象都不能读取、设置备忘录，只有Originator类才能进行备忘录的读取和设置。由于备忘录主要是用于对对象的状态进行备份，实现了撤销操作，如果对象的状态数据很大很多时，在进行备忘时，就会很占用资源，这个是我们在实际开发时需要考虑的东西。结合之前的设计模式，在总结命令模式时，说到命令模式支持事物的回退，而这个就是依靠的备忘录模式来实现的。好了，备忘录模式就总结至此。希望对大家有用

本页共20段，1722个字符，4570 Byte(字节)


大
中
小
↓
∨