我所理解的设计模式（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】

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