备忘录模式

定义：

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

（备忘录模式可以理解为一种用于记录的模式（历史记录），平时使用的world，ppt等软件都有这种记录历史的功能，能够很好的切换到之前某个节点。 

这种记录也可以和事务处理相结合，事务处理中牵扯到回滚功能，就可以使用备忘录模式。）

优点： 
1、备忘录模式可以把复杂的对象内部信息对其他的对象屏蔽起来，从而可以保持封装的边界。 
2、简化了发起人类。当发起人角色的状态改变的时候，有可能这个状态无效，这时候就可以使用暂时存储起来的备忘录将状态复原。

缺点： 
1、如果状态需要完整地存储到备忘录对象中，那么在资源消耗上面备忘录对象比较昂贵。 

2、当发起者对象的状态改变的时候，有可能这个协议无效。如果状态改变的成功率达不到要求，可以考虑采取“假如”协议模式。

适用性：

Memento模式适用于功能比较复杂的，但需要维护或记录属性历史的类，或者需要保存的属性只是众多属性中的一小部分时，Originator可以根据保存的Memento信息还原到前一状态。

UML图：

Originator(发起人)：负责创建一个备忘录Memento，用以记录当前时刻它的内部状态，并可使用备忘录恢复内部状态，Originator可根据需要决定Memento存储Originator的哪些内部状态

Memento(备忘录)：负责存储Originator对象的内部状态，并可防止Originator以外的其他对象访问备忘录Memento

Caretaker(管理者)：负责保存好备忘录Memento，不能对备忘录的内容进行操作或检查

备忘录Memento有两个等效的接口：

窄接口：负责人（Caretaker）对象（和其他除发起人对象之外的任何对象）看到的是备忘录的窄接口(narrow interface)，这个窄接口只允许它把备忘录对象传给其他的对象。 
宽接口：与负责人对象看到的窄接口相反的是，发起人对象可以看到一个宽接口(wide interface)，这个宽接口允许它读取所有的数据，以便根据这些数据恢复这个发起人对象的内部状态。

备忘录模式基本代码：

#include <iostream>
#include <string>

using namespace std;

//负责存储Originator对象的内部状态，并可防止Originator以外的其他对象访问备忘录Memento。
//备忘录有两个接口，Caretaker只能看到备忘录的窄接口，它只能将备忘录传递给其他对象。Originator能够看到一个宽接口，允许它访问返回到先前状态所需的所有数据。
class Memento
{
private:
    //将Originator为friend类，可以访问内部信息，但是其他类不能访问
    friend class Originator;
    Memento(const string& state):_state(state){}
    ~Memento(){}
    void SetState(const string& state){_state=state;}
    string GetState(){return _state;}

    string _state;//Originator对象的内部状态
};

//负责创建一个备忘录Memento，用以记录当前时刻它的内部状态，并可使用备忘录恢复内部状态
class Originator
{
public:
    Originator(){}
    Originator(const string& state):_state(state){}
    ~Originator(){}
    void RestoreToMemento(Memento* pMemento)//恢复备忘录，将Memento导入并将相关数据恢复
    {
        _state=pMemento->GetState();
    }
    Memento* CreateMemento()//创建备忘录，将当前需要保存的信息导入并实例化出一个Memento对象
    {
        return new Memento(_state);
    }
    void SetState(const string& state){_state=state;}
    string GetState(){return _state;}
    void show(){cout<<_state<<endl;}
protected:
private:
    string _state;//需要保存的属性，可能有多个
};

//负责保存好备忘录Memento,不能对备忘录的内容进行操作或检查
class Caretaker
{
public:
    Caretaker(){}
    ~Caretaker(){}
    void SetMemento(Memento* memento){_memento=memento;}
    Memento* GetMemento(){return _memento;}
private:
    Memento* _memento;
};

int main()
{
    //初始化对象，状态为“Old”
    Originator* o = new Originator("Old");
    o->show();

    //建立并保存Memento
    Caretaker* pTaker = new Caretaker();
    pTaker->SetMemento(o->CreateMemento());

    //改变状态
    o->SetState("New");
    o->show();

    //恢复状态
    o->RestoreToMemento(pTaker->GetMemento());
    o->show();

    return 0;
}

例子：

#include <iostream>
#include <stdlib.h>
#include <string>
#include <time.h>
#include <map>

using namespace std;

//备忘录类
class Memento{
public:
    Memento(int hp=0, int mp=0, int atk=0):mHp(hp),mMp(mp),mAttack(atk){}

public:
    int mHp;
    int mMp;
    int mAttack;
};

//角色状态管理类
class Caretaker
{
public:
    Memento* GetState(string key)
    {
        return mData[key];
    }
    void SetState(string key, Memento* pMemento)
    {
        mData[key] = pMemento;
    }
    ~Caretaker()
    {
        map<string, Memento*>::iterator it = mData.begin();
        for(; it != mData.end(); it++)
        {
            if(mData.count("he") && it->second != NULL)
            {
                delete it->second;
            }
        }
        mData.clear();
    }

private:
    map<string, Memento*> mData;
};

//角色类
class Hero{
public:
    Hero(int hp=100, int mp=100, int at=100):mHp(hp), mMp(mp), mAttack(at), mCaretaker(new Caretaker()){}

    void saveState(string key)
    {
        Memento* pMemento = new Memento(mHp, mMp, mAttack);
        mCaretaker->SetState(key, pMemento);
    }

    void resumeState(string key)
    {
        Memento* mmt = mCaretaker->GetState(key);
        mHp = mmt->mHp;
        mMp = mmt->mMp;
        mAttack = mmt->mAttack;
    }

    void battle()
    {
        mHp = rand()%100;
        mMp = rand()%100;
        mAttack = rand()%100;
    }

    void showState()
    {
        cout<<"血量："<<mHp<<endl
            <<"蓝量："<<mMp<<endl
            <<"攻击："<<mAttack<<endl;
    }

private:
    int mHp;
    int mMp;
    int mAttack;
    Caretaker* mCaretaker;
};

int main()
{
    srand((unsigned int) time(NULL));

    Caretaker *ctk=new Caretaker();//管理者
    Hero *hero=new Hero();//角色
    Memento *mmt=new Memento();//备忘录

    cout<<"----战斗前-----"<<endl;
    hero->showState();//显示初始状态
    cout<<endl;
    hero->saveState("战斗前");//保存战斗前的状态，到备忘录中

    hero->battle();
    cout<<"-----战斗1后-----"<<endl;
    hero->showState();//显示战斗1后状态
    cout<<endl;
    hero->saveState("战斗1后");//保存战斗1后的状态，到备忘录中

    hero->battle();
    cout<<"-----战斗2后-----"<<endl;
    hero->showState();
    hero->saveState("战斗2后");
    cout<<endl;

    hero->battle();
    cout<<"-----战斗3后-----"<<endl;
    hero->showState();
    hero->saveState("战斗3后");
    cout<<endl;

    hero->resumeState("战斗1后");
    cout<<"-----恢复战斗1结果-----"<<endl;
    hero->showState();
    cout<<endl;

    hero->resumeState("战斗前");
    cout<<"-----恢复战斗前-----"<<endl;
    hero->showState();
    cout<<endl;

    return 0;
}