备忘录模式(Memento)C++实现

备忘录模式

意图：

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

适用性：

1、必须保存一个对象在某一个时刻的部分状态，这样以后需要时它才能恢复到先前的状态。

2、如果一个用接口来让其它对象直接得到这些状态，将会暴露对象的实现细节并破坏对象的封装性。

UML：

代码实现：实现保存游戏中英雄的不同状态，并能恢复到对应状态。

 #include <iostream>
 #include "memento.h"
 #include <string>
 #include <time.h>
 #include <map>

 using namespace std;

 class Memento{
 public:
     Memento(int hp=, int mp=, int atk=)
     {
         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()
     {
         auto it = mData.begin();
         for(; it != mData.end(); it++)
         {
             if(mData.count("he") && it->second != nullptr)
             {
                 delete it->second;
             }
         }
         mData.clear();
     }

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

 class Hero{
 public:
     Hero(int hp=, int mp=, int at=):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)
     {
         auto mmt = mCaretaker->GetState(key);
         mHp = mmt->mHp;
         mMp = mmt->mMp;
         mAttack = mmt->mAttack;
     }

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

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

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

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

     Caretaker ctk;
     Hero hero;
     Memento mmt;

     cout<<"----战斗前-----"<<endl;
     hero.showState();
     cout<<endl;
     hero.saveState("战斗前");

     hero.battle();
     cout<<"-----战斗1后-----"<<endl;
     hero.showState();
     cout<<endl;
     hero.saveState("战斗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;
 }

结果：

这样客户端实现了保存状态和恢复到对应状态，而内部处理过程却不知道。