Memento

Memento

在不破坏封装性的前提下，捕获一个对象（Originator）的内部状态，并在该对象之外（memento）保存这个状态，这样以后就可将该对象恢复到原先保存的状态。
Memento除了析构函数，其它成员均为私有，将Originator声明为友元，只允许它访问。Memento中保存了Originator的状态。

#include  < iostream >

using   namespace  std;


class  Originator;

// Memento类，记录状态
// 除了析构函数，所有成员私有，声明Originator为友元，只允许它访问
class  Memento
{
public:
    ~Memento(){}
private:
    friend class Originator;
    Memento(int i):state(i){}
    void SetState(int i){state = i;}
    int GetState(){return state;}
    int state;
} ;

// Originator类
class  Originator
{
public:
    Originator(int i):current_state(i){}
    //创建Memento
    Memento* CreateMemento()
    {
        return new Memento(current_state);
    }
    void SetMemento(Memento* p)
    {
        p->SetState(current_state);
    }
    //将自己的状态恢复至Memento中保存的状态
    void RestoreMemento(Memento* p)
    {
        current_state = p->GetState();
    }
    void ChangeState()
    {
        ++current_state;
    }
    void PrintState() const
    {
        cout<<current_state<<endl;
    }
private:
    int current_state;
} ;

int  main()
{
    Originator* po = new Originator(5);
    po->PrintState();    //5 in originator
    
    Memento* pm = po->CreateMemento();    //5 in memento

    po->ChangeState();    //6 in originator
    po->PrintState();

    po->RestoreMemento(pm);    //5 in originator
    po->PrintState();

    delete pm;
    delete po;
    
    return 0;
}