Memento.h
#ifndef __MEMENTO_H_
#define __MEMENTO_H_
#include <string>
using namespace std;
typedef string State;
class CMemento;
class COriginator
{
public:
COriginator();
COriginator(const State&st);
CMemento *CreateMemento();
State GetState();
void SetMemento(CMemento *_mt);
void ResortMemento(CMemento *_mt);
void SetState(const State&st);
void PrintState();
~COriginator();
private:
State _sdt;
CMemento *_mt;
};
class CMemento
{
public:
~CMemento();
private:
friend class COriginator;
CMemento();
CMemento(const State&st);
State GetState();
void SetState(const State&st);
private:
State _sdt;
};
#endif
Memento.cpp
#include <iostream>
#include "Memento.h"
using namespace std;
COriginator::COriginator()
{
_sdt="\0";
_mt=0;
}
COriginator::~COriginator()
{
if(_mt)
{
delete _mt;
_mt=0;
}
}
COriginator::COriginator(const State &st)
{
_sdt=st;
_mt=0;
}
CMemento* COriginator::CreateMemento()
{
return new CMemento(_sdt);
}
void COriginator::SetState(const State &st)
{
_sdt=st;
}
void COriginator::SetMemento(CMemento *_mt)
{
}
void COriginator::ResortMemento(CMemento *_mt)
{
this->_sdt=_mt->GetState();
}
void COriginator::PrintState()
{
cout<<"......"<<this->_sdt<<endl;
}
State COriginator::GetState()
{
return _sdt;
}
CMemento::CMemento()
{
}
CMemento::~CMemento()
{
}
CMemento::CMemento(const State &st)
{
_sdt=st;
}
void CMemento::SetState(const State &st)
{
_sdt=st;
}
State CMemento::GetState()
{
return _sdt;
}
Main.cpp
#include <iostream>
#include "Memento.h"
using namespace std;
int main() //Client
{
COriginator *o=new COriginator();
o->SetState("old");
o->PrintState();
CMemento *m=o->CreateMemento();
o->SetState("new");
o->PrintState();
o->ResortMemento(m);
o->PrintState();
if(o)
{
delete o;
o=0;
}
if(m)
{
delete m;
m=0;
}
return 0;
}
Memento模式的关键就是friend class Originator;我们可以看到，Memento的接口都声明为private，而将Originator声明为Memento的友元类。我们将Originator的状态保存在Memento类中，而将Memento接口private起来，也就达到了封装的功效。
在Originator类中我们提供了方法让用户后悔：RestoreToMemento(Memento* mt)；我们可以通过这个接口让用户后悔。在测试程序中，我们演示了这一点：Originator的状态由old变为new最后又回到了old。