首页 > 代码库 > C++设计模式实现--备忘录(Memento)模式

C++设计模式实现--备忘录(Memento)模式

2024-07-08 14:06:10   230人阅读

一. 备忘录模式

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

结构图：


使用范围：

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

代码：

[cpp] view plaincopy
  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 是开放的。


联系
我们