设计模式C++描述----17.备忘录(Memento)模式

一. 备忘录模式

定义：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态。

结构图：

使用范围：

Memento 模式比较适用于功能比较复杂的，但需要维护或记录属性历史的类，或者需要保存的属性只是众多属性中的一小部分时，Originator 可以根据保存的 Memento 信息还原到前一状态。

代码：

[cpp]  view plain copy

1. //备忘录类  
2. //负责存储 Originator 对象的内部状态  
3. class Memento   
4. {  
5. //注意：备忘录类中的方法是私有的！！！！！！！  
6. private:   
7.     //这是最关键的地方，将 Originator 为friend类  
8.     //这样 Originator 就可以访问 Memento 类的内部信息  
9.     friend class Originator;   
10.   
11.     Memento() {}  
12.   
13.     Memento(const string& sdt)  
14.     {  
15.         _sdt = sdt;  
16.     }  
17.   
18.     void SetState(const string& sdt)  
19.     {  
20.         _sdt = sdt;  
21.     }  
22.                        
23.     string GetState()  
24.     {  
25.         return _sdt;  
26.     }  
27.   
28. private:  
29.     string _sdt;  
30.   
31. };  
32.   
33. //原始类  
34. //负责创建备忘录  
35. class Originator   
36. {  
37. public:   
38.     Originator()  
39.     {  
40.         _sdt = "";  
41.         _mt = 0;   
42.     }  
43.   
44.     Originator(const string& sdt)  
45.     {  
46.         _sdt = sdt;        
47.         _mt = 0;   
48.     }  
49.   
50.     //创建备忘录，将当前信息保存在一个备忘录对象中  
51.     Memento* CreateMemento()  
52.     {  
53.         return new Memento(_sdt);   
54.     }  
55.   
56.     //恢复备忘录，将备忘录对象上的信息恢复出来  
57.     void RestoreToMemento(Memento* mt)  
58.     {  
59.         this->_sdt = mt->GetState();  
60.     }  
61.   
62.     string GetState()  
63.     {  
64.         return _sdt;  
65.     }  
66.   
67.     void SetState(const string& sdt)  
68.     {  
69.         _sdt = sdt;   
70.     }  
71.   
72.     void PrintState()  
73.     {  
74.         cout<<this->_sdt<<"....."<<endl;   
75.     }  
76.   
77. private:   
78.     string _sdt;  
79.     Memento* _mt;   
80. };  
81.                    
82.   
83. //测试代码  
84. int main(int argc,char* argv[])   
85. {  
86.     Originator* o = new Originator();  
87.   
88.     o->SetState("old"); //备忘以前的状态  
89.     o->PrintState();  
90.   
91.     Memento* m = o->CreateMemento(); //创建一个备忘录  
92.     o->SetState("new"); //修改状态  
93.     o->PrintState();  
94.   
95.     o->RestoreToMemento(m); //恢复修改前的状态  
96.     o->PrintState();  
97.   
98.     return 0;  
99. }  

二. 说明

1. Memento 负责存储 Originator 对象的内部状态，并可防止 Originator 以外的其它对象访问备忘录（具体实现方法，就是让其所有方法都为私有的）。

2. Memento 声明 Originator 为它的友元类，这样 Originator 就可以访问它的所有函数，即对 Originator 是开放的。

我觉得，私有和友元是备忘录模式实现的关键！

转自：http://blog.csdn.net/lwbeyond/article/details/7572707