Memento模式

Memento（备忘录）模式

一个类有很多状态，在开发时有时会遇到想把这个类恢复到之前某一个状态(例如撤销)，这时候就用到了Memento模式．

Memento模式思想比较简单，就是创建一个类Memento对象来记录另一个类的状态，可以用这个Memento对象将它恢复到创建它时的状态．

用类图表示如下：

在实现时，类Memento所有方法都为private，类Originator为其友元，这样其他类就无法使用Memento类．

//Memento.h

#ifndef _MEMENTO_H_
#define _MEMENTO_H_
#include <string>

typedef std::string State;
class Memento;
class Originator
{
public:
    Originator();
    Originator(const State& sdt);
    ~Originator();
    Memento* CreateMemento();
    void SetMemento(Memento* men);
    void RestoreToMemento(Memento* mt);
    State GetState();
    void SetState(const State& sdr);
    void PrintState();
private:
    State sdt_;
    Memento* mt_;

};

class Memento
{
private:
    friend class Originator;
    Memento();
    Memento(const State& sdt);
    ~Memento();
    void SetState(const State& sdt);
    State GetState();
    State sdt_;

};


#endif

//Memento.cpp

#include "Memento.h"
#include <iostream>

Originator::Originator()
{
    sdt_ = "";
    mt_ = NULL;
}
Originator::Originator(const State& sdt)
{
    sdt_ = sdt;
    mt_ = NULL;
}
Originator::~Originator()
{}
Memento* Originator::CreateMemento()
{
    return new Memento(sdt_);
}
State Originator::GetState()
{
    return sdt_;
}
void Originator::SetState(const State& sdt)
{
    sdt_ = sdt;
}
void Originator::PrintState()
{
    std::cout << sdt_ << std::endl;
}
void Originator::SetMemento(Memento* men)
{
    mt_ = men;
}
void Originator::RestoreToMemento(Memento* mt)
{
    sdt_ = mt->GetState();
}

Memento::Memento()
{

}
Memento::Memento(const State& sdt)
{
    sdt_ = sdt;
}
State Memento::GetState()
{
    return sdt_;
}
void Memento::SetState(const State& sdt)
{
    sdt_ = sdt;
}

//main.cpp

#include "Memento.h"
int main()
{
    Originator* o = new Originator();
    o->SetState("old");
    o->PrintState();
    Memento* m = o->CreateMemento();

    o->SetState("new");
    o->PrintState();

    o->RestoreToMemento(m);
    o->PrintState();

    return 0;
}