我所理解的设计模式（C++实现）——备忘录模式（Memento Pattern）

概述：

我们玩单机游戏的时候总会遇到老婆大人的各位事情，一会去买瓶醋了，一会去打个酱油了，会耽误我们玩游戏的进程，但是此时我们能有“保存游戏”这个宝贝，我们的主基地不会在我们打酱油的时候被对手拆掉。

这“保存游戏”的功能其实就是备忘录模式的很好应用，她是在不破坏封装的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可以就该对象恢复到原先保存的状态。这个其实也是我们的redo，undo所采用的模式。

类图和实例：

简单的模式实例，来源于
网上：

#include <iostream>
using namespace std;
class NumberMemento
{
friend class NumberOriginator;/*Friend Class for wide interface*/
public:
NumberMemento(){}
virtual ~NumberMemento(){}
/*narrow interface for state*/
virtual int GetNumberState()
{
return this->numberstate;
}

virtual void SetNumberState(int _newnumber)
{
this->numberstate=_newnumber;
return;
}

private:/*private is for encapsulation*/
int numberstate; /*wide interface for state*/

};

class MementoManager
{
public:
MementoManager(){}
virtual ~MementoManager(){}
/*interface to provide memento*/
virtual void SaveMemento(NumberMemento *_nummemento)
{
this->nummemento=_nummemento;
return;
}
virtual NumberMemento *GetMemento()
{
if(nummemento!=NULL)
return this->nummemento;
else
{
cout<<"No Memento Existed in MementoManager......Please create a memento for MementoManager first!"<<endl;
return NULL;
}
}

private:
NumberMemento *nummemento;// be managed memento,can be a list mementos
};

class NumberOriginator
{
public:
NumberOriginator(int _numstate,MementoManager *_manager)
{
this->NumberState=_numstate;
this->mementomanager=_manager;/*Conncetion with manager*/
}
virtual ~NumberOriginator(){}

virtual int getNumberState()
{
return this->NumberState;
}
virtual void SetNumberState(int _numstate)
{
this->StoreToMemento();
this->NumberState=_numstate;
return;
}
virtual void RestoreNumberState()/*Undo Operation*/
{
int lastState=(this->mementomanager->GetMemento())->numberstate;/*tell manager that I need memento state*/
(this->mementomanager->GetMemento())->numberstate=this->NumberState;
this->NumberState=lastState;
return;
}
protected:
virtual void StoreToMemento()
{
(this->mementomanager->GetMemento())->numberstate=this->NumberState;/*Use Wide Interface to memento */
return;
}
private:/*Important: 状态的封装性不能被破环*/
int NumberState;/*Number State*/
MementoManager *mementomanager;
};

int main (int argc, char *argv[])
{
/*New A memento and a Manager,and give the memento to manager*/
NumberMemento *memento=new NumberMemento();
MementoManager *caretaker=new MementoManager();
caretaker->SaveMemento(memento);
/*There is a number originator,it ask manager for memento*/
NumberOriginator *num=new NumberOriginator(11,caretaker);
cout<<"\nNumber Original State: "<<num->getNumberState()<<endl;
num->SetNumberState(22);
cout<<"\nNow Number State set tobe: "<<num->getNumberState()<<endl;
num->RestoreNumberState();/*Now Undo it*/
cout<<"\nNow Restore it(with Memento): "<<num->getNumberState()<<endl;
return(0);
}

适用性：

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

前提与说明：

备忘录模式使用的前提：

1) 必须保存一个对象在某一个时刻的(部分)状态, 这样以后需要时它才能恢复到先前的状态。

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

关于第1点，如果备份的对象存在大量的信息或者创建、恢复操作非常频繁，则可能造成很大的性能开销。

关于第2点，我们可以让Memento声明Originator为她的私有友元类，这样Originator就可以访问Memento的所有函数。

LCL_data原创于CSDN.NET【http://blog.csdn.net/lcl_data/article/details/9745019】

其他设计模式文章请参考：我所理解的设计模式