设计模式(18)-行为型模式-MEMENTO模式

3.5           MEMENTO模式

3.6.1 功能

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

                一个备忘录 （memento）是一个对象,  它存储另一个对象在某个瞬间的内部状态，而后者称为备忘录的原发器 ( originator)。只有原发器可以向备忘录中存取信息，备忘录对其他的对象 “不可见”。

 

3.6.2 结构

               

•  M e m e n t o( 备忘录，如S o l v e r S t a t e )

— 备忘录存储原发器对象的内部状态。原发器根据需要决定备忘录存储原发器的哪些

内部状态。

— 防止原发器以外的其他对象访问备忘录。备忘录实际上有两个接口，管理者

( c a r e t a k e r )只能看到备忘录的窄接口—它只能将备忘录传递给其他对象。相反 ,  原

发器能够看到一个宽接口,  允许它访问返回到先前状态所需的所有数据。理想的情况

是只允许生成本备忘录的那个原发器访问本备忘录的内部状态。

•  O r i g i n a t o r( 原发器，如 C o n s t r a i n t S ol v e r )

— 原发器创建一个备忘录,用以记录当前时刻它的内部状态。

— 使用备忘录恢复内部状态.。

•  C a r e t a k e r(负责人，如 undo mechanism)

— 负责保存好备忘录。

— 不能对备忘录的内容进行操作或检查。

3.6.3 协作

• 管理器向原发器请求一个备忘录,  保留一段时间后 , 将其送回给原发器 ,  如下面的交互图所示。

3.6.4 C++代码示例

下面这段代码没有引入caretaker，不过也大致表达了memento的核心观点.

//Memento.h

#ifndef _MEMENTO_H_

#define _MEMENTO_H_

#include<string>

using namespace std;

class Memento;

classOriginator

{

public:

       typedef string State;

       Originator();

       Originator(constState&sdt);

       ~Originator();

       Memento* CreateMemento();

       void SetMemento(Memento* men);

       void RestoreToMemento(Memento* mt);

       State GetState();

       void SetState(const State&sdt);

       void PrintState();

protected:

private:

       State _sdt;

       Memento* _mt;

};

classMemento

{

public:

protected:

private:

//这是最关键的地方，将Originator为friend类，可以访问内部信息，但是其他类不能访问

       friend class Originator;

       typedef string State;

       Memento();

       Memento(const State& sdt);

       ~Memento();

       void SetState(const State&sdt);

       State GetState();

private:

       State _sdt;

};

#endif //~_MEMENTO_H_

 

//Memento.cpp

StateOriginator::GetState()

{

       return _sdt;

}

void Originator::SetState(const State&sdt)

{

       _sdt = sdt;

}

void Originator::PrintState()

{

       cout << this->_sdt << "....."<< endl;

}

void Originator::SetMemento(Memento* men)

{

}

void

Originator::RestoreToMemento(Memento*mt)

{

       this->_sdt = mt->GetState();

}

//classMemento

Memento::Memento()

{

}

Memento::Memento(constState&sdt)

{

       _sdt = sdt;

}

StateMemento::GetState()

{

       return _sdt;

}

void Memento::SetState(const State& sdt)

{

       _sdt = sdt;

}

 

//main.cpp

#include"Memento.h"

#include<iostream>

using namespace std;

int main(int argc,char*argv[])

{

       Originator* o = new Originator();

       o->SetState("old"); //备忘前状态

       o->PrintState();

       Memento* m = o->CreateMemento(); //将状态备忘

       o->SetState("new"); //修改状态

       o->PrintState();

       //It’s better if

       o->RestoreToMemento(m);    //恢复修改前状态

       o->PrintState();

       return 0;

}