设计模式之备忘录模式（mememto）

概念
Memento模式也叫备忘录模式，是行为模式之一，它的作用是保存对象的内部状态，并在需要的时候（undo/rollback）恢复对象以前的状态。
在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这一状态，这样以后就可以将该对象恢复到原先保存的状态

设计要点
Memento 模式中封装的是需要保存的状态,当需要恢复的时候才取出来进行恢 复.原理很简单,实现的时候需要注意一个地方:窄接口和宽接口.所谓的宽接口就 是一般意义上的接口,把对外的接口作为 public 成员;而窄接口反之,把接口作为 private 成员,而把需要访问这些接口函数的类作为这个类的友元类,也就是说接 口只暴露给了对这些接口感兴趣的类,而不是暴露在外部.下面的实现就是窄实 现的方法来实现的.

Originator（原生者）
需要被保存状态以便恢复的那个对象。
Memento（备忘录）
该对象由Originator创建，主要用来保存Originator的内部状态。
Caretaker（管理者）
负责在适当的时间保存/恢复Originator对象的状态。
适用于：
在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，这样就可以将以后的对象状态恢复到先前保存的状态。
适用于功能比较复杂的，但需要记录或维护属性历史的类；或者需要保存的属性只是众多属性中的一小部分时Originator可以根据保存的Memo还原到前一状态。

如果一个对象需要保存状态并可通过undo或rollback等操作恢复到以前的状态时，可以使用Memento模式。

1）一个类需要保存它的对象的状态（相当于Originator角色）

2）设计一个类，该类只是用来保存上述对象的状态（相当于Memento角色）

3）需要的时候，Caretaker角色要求Originator返回一个Memento并加以保存

4）undo或rollback操作时，通过Caretaker保存的Memento恢复Originator对象的状态

class MememTo
{
public:
         MememTo(string name, int age)
         {
                  this->m_name = name;
                  this->m_age= age;
         }
         void setName(string name)
         {
                  this->m_name = name;
         }
         string getName()
         {
                  return m_name;
         }
         void setAge(int  age)
         {
                  this->m_age= age;
         }
         int getAge()
         {
                  return m_age;
         }
protected:
private:
         string        m_name;
         int             m_age;
};
class Person
{
public:
         Person(string name, int age)
         {
                  this->m_name= name;
                  this->m_age= age;
         }
         void setName(string name)
         {
                  this->m_name = name;
         }
         string getName()
         {
                  return m_name;
         }
         void setAge(int  age)
         {
                  this->m_age = age;
         }
         int getAge()
         {
                  return m_age;
         }
         void printT()
         {
                  cout<< "name: " << m_name << "age: " <<
m_age << endl;
         }
 
public:
 
         //创建备份
         MememTo *createMememTo()
         {
                  return new MememTo(m_name, m_age);
         }
 
         //恢复备份
         void SetMememTo(MememTo *memto)

         {

                  m_name
= memto->getName();

                  m_age
= memto->getAge();

         }

 

protected:

private:

         string        m_name;
         int             m_age; 
};
 
//管理者
class Caretaker
{
public:
         Caretaker(MememTo *mem)         {
                  this->m_memto= mem;
         }
         MememTo*getMememTo()
         {
                  return m_memto;
         }
         void setMememTo(MememTo *mem)
         {
                  this->m_memto = mem;
         }
protected:
private:
         MememTo*m_memto;
};
void main23_01()
{
         Person *p = new Person("张三", 18);
         p->printT();
         //创建备份
         Caretaker*ct = new Caretaker(p->createMememTo());       
         p->setAge(28);
         p->printT();
 
         //恢复信息
         p->SetMememTo(ct->getMememTo());
         p->printT();
 
         delete p;
         delete ct->getMememTo();
 
         return ;
}
 
void main23_02()
{
         Person *p = new Person("张三", 18);
         p->printT();
 
         //创建备份
         MememTo * membak = p->createMememTo();
         p->setAge(28);
         p->printT();
 
         //恢复信息
         p->SetMememTo(membak);
         p->printT();
 
         delete p;
         delete membak;
}
void main()

{
         //main23_01();
         main23_02();
         system("pause");
}

总结

备忘录模式存储原发器对象的内状态，在需要时恢复原发器状态。

Memento模式的核心是信息隐藏，即Originator需要向外界隐藏信息，并同时有需要将状态保持到外界

由于现代语言运行时都具有相当的对象序列化支持，因此往往采用效率较高，又较容易正确实现的序列化方案来实现Memento模式