Memento 备忘录模式

        Memento 备忘录模式: 在不破坏封装性的前提下,捕获一个对象的内部状态, 并在该对象之外保存这个状态.这样以后就可以将该对象恢复到原先保存的状态. 一个备忘录(memento)是一个对象,它存储另一个对象在某个瞬间的内部状态, 而后者称为备忘录的原发器(originator). 当需要设置原发器的检查点时, 取消操作机制会向原发器请求一个备忘录. 原发器用描述当前状态的信息初始化该备忘录. 只有原发器可以向忘录中存取信息,备忘录对其它的对象"不可见".

    Memento 备忘录模式适用于: 1.必须保存一个对象在某一时刻的(部分)状态, 这样以后需要它时才能恢复到先前的状态. 2.如果一个用户接口来让其它对象直接得到这些状态, 将会暴露对象的实现细节并破坏对象的封装性.

Memento 备忘录模式的通用结构如下:

参与者:

Memento: 备忘录, 存储原发器对象的内部状态. 原发器根据需要决定备忘录存储原发器的哪些内部状态.防止原发器以外的其它对象访问备忘录; 备忘录实际上有两个接口, 管理者(caretaker)只能看到备忘录的窄接口---它只能将备忘录传递给其他对象. 相反, 原发器能够看见到一个宽接口, 允许它访问返回到先前状态所需的所有数据. 理想的情况是只允许生成本备忘录的那个原发器访问本备忘录的内部状态.

Originator: 原发器, 创建一个备忘录, 用以记录当前时刻它的内部状态.使用备忘录恢复内部状态.

Caretaker: 负责人, 负责保存好备忘录, 不能对备忘录的内容进行操作或检查.

管理向原发器请求一个备忘录, 保留一段时间后,将其送回给原发器. 备忘录是被动的, 只有创建备忘录的原发器会对它的状态进行赋值和检索.

 

Memento 备忘录模式代码示例:

   1:  #pragma once

   2:   

   3:  #include <string>

   4:   

   5:  typedef std::string State;

   6:   

   7:  class Memento;

   8:   

   9:  //备忘录有两个接口: 一个为原发器所使用的宽接口, 一个为其它对象所使用的窄接口

  10:  //理想的实现语言应可支持两级的静态保护. 在 C++ 中, 可将 Originator 作为 

  11:  //Memento 的一个友元, 并使 Memento 宽接口为私有的. 只有窄接口应该被声明为公共的.

  12:   

  13:  // 原发器

  14:  class Originator

  15:  {

  16:  public:

  17:      Originator(const State& rState);

  18:      Originator();

  19:      ~Originator();

  20:   

  21:      Memento*    CreateMemento();

  22:      void        SetMemento(Memento* pMemento);

  23:   

  24:      State*        GetState();

  25:      void        SetState(const State& rState);

  26:      void        RestoreState(Memento* pMemento);

  27:      void        PrintState();

  28:   

  29:  private:

  30:      State*        m_State;

  31:  };

  32:   

  33:  // 把 Memento 的接口函数都设置为私有的,而 Originator 是它的友元

  34:  // 这样保证了只有 Originator 可以对其访问

  35:  class Memento

  36:  {

  37:  private:

  38:      friend class Originator;

  39:      Memento(const State& rState);

  40:      void    SetState(const State& rState);

  41:      State*    GetState();

  42:   

  43:      State*    m_State;

  44:  public:

  45:      //供其它对象使用的宽接口

  46:      virtual ~Memento();

  47:  };

  48:   

   1:   

   2:  #include "Memento.h"

   3:  #include 
  
  

   4:   

   5:  Originator::Originator(){    }

   6:  Originator::Originator(const State& rState)

   7:      :m_State(new std::string(rState)){    }

   8:   

   9:  Originator::~Originator(){    }

  10:   

  11:  State* Originator::GetState()

  12:  {

  13:      return m_State;

  14:  }

  15:   

  16:  void Originator::SetState(const State& rState)

  17:  {

  18:      m_State = new std::string(rState);

  19:  }

  20:   

  21:  Memento* Originator::CreateMemento()

  22:  {

  23:      return new Memento(*m_State);

  24:  }

  25:   

  26:  void Originator::RestoreState(Memento* pMemento)

  27:  {

  28:      if (NULL != pMemento)

  29:      {

  30:          m_State = pMemento->GetState();

  31:      }    

  32:  }

  33:   

  34:  void Originator::PrintState()

  35:  {

  36:      std::cout << "State = " << *m_State << std::endl;

  37:  }

  38:   

  39:  

  40:  Memento::Memento(const State& rState)

  41:      : m_State(new std::string(rState)){    }

  42:  Memento::~Memento(){    }

  43:   

  44:  State* Memento::GetState()

  45:  {

  46:      return m_State;

  47:  }

  48:   

  49:  void Memento::SetState(const State& rState)

  50:  {

  51:      m_State = new std::string(rState);

  52:  }

   1:   

   2:  #include "Memento.h"

   3:  #include 
  
  

   4:   

   5:  int main()

   6:  {

   7:      // 创建一个原发器

   8:      Originator* pOriginator = new Originator("old state");

   9:      pOriginator->PrintState();

  10:   

  11:      // 创建一个备忘录存放这个原发器的状态

  12:      Memento *pMemento = pOriginator->CreateMemento();

  13:      

  14:      // 更改原发器的状态

  15:      pOriginator->SetState("new state");

  16:      pOriginator->PrintState();

  17:   

  18:      // 通过备忘录把原发器的状态还原到之前的状态

  19:      pOriginator->RestoreState(pMemento);

  20:      pOriginator->PrintState();

  21:   

  22:      delete pOriginator;

  23:      delete pMemento;

  24:   

  25:      return EXIT_SUCCESS;

  26:  }