【设计模式】如果再回到从前 ---- 备忘录模式

一，概述

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

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

　　2.Memento(备忘录)：负责存储Originator对象的内部状态，并可以防止Originator以外的其他对象访问备忘录。备忘录有两个接口：Caretaker只能看到备忘录的窄接口，他只能将备忘录传递给其他对象。Originator却可看到备忘录的宽接口，允许它访问返回到先前状态所需要的所有数据。

　　3.Caretaker(管理者):负责备忘录Memento，不能对Memento的内容进行访问或者操作。

二，基本代码格式

#include <iostream>
using namespace std;
  
class Memento//备忘录，存储 Originator内部状态 
{
private: 
		string state;

public:
		 Memento(string state)
        {
            this->state = state;
        }

        string getState() 
        {
            return state; 
        }
}; 

class Originator//发起人，创建备忘录 
{
private:
		 string state;
public: 
		 string getState() 
        {
        	return state;
       	} 
            
        void setState(string value)
		 { 
		     this->state = value;
		 }
    

        Memento* CreateMemento()//创建备忘录 
       {
           return (new Memento(state));
        }

         void SetMemento(Memento *memento)
        {
            this->state = memento->getState();
        }
        void Show()//显示备忘录状态 
        {
            cout<<"State="<<state<<endl;
        }
    }; 



class Caretaker//管理者 
{
public:
		   Memento *memento;

public:
		   Memento* getMemento()//返回备忘录状态 
		   {
		   	  return memento; 
		   } 
		   Memento* setMemento(Memento *mymemento)//设定备忘录状态 
		   {
		   	  this->memento=mymemento; 
		   } 
          
}; 
int main()
{

            Originator *o = new Originator();//发起人 
            o->setState("On");
            o->Show();

            Caretaker *c = new Caretaker();//管理者 
            c->setMemento(o->CreateMemento());//保存状态 
            
            o->setState("Off");//当游戏挂掉 
            o->Show();

            o->SetMemento(c->getMemento());//恢复之前保存的备忘录状态 
            o->Show();
             

}
        

三，示例（存储游戏进度）

玩游戏的时候，通常为了可以重复玩某一关关卡，在闯关之前先保存游戏状态。然后，假如没有闯关成功，再恢复到之前的状态重新闯关。

1）最原始的存储游戏进度方法

方法：新建立一个游戏角色类，用以保存状态。

当需要恢复状态的时候，让状态存储类的数据恢复到游戏角色类中

缺点：暴漏了实现细节

#include <iostream>
using namespace std; 
    class GameRole
    {
        //生命力
        private:
		   int vit;
        
        public:
		   int getVitality() 
        {
           return vit; 
	     }
	     
         void   setVitality(int value) 
		  { 
		     this->vit = value; 
         }
        

        //攻击力
        private:
		    int atk;
        public:
		   int getAttack() 
    	   {
            	return atk; 
       	   } 
          void setAttack(int value) 
          {
		   		this->atk = value; 
		  }
        

        //防御力
        private:
		   int def;
        public: 
        int getDefense() 
        {
        	 return def;
       	} 
         void setDefense(int value) 
        {
        	 this->def = value;
       	} 
         

        //状态显示
        void StateDisplay()
        {
            cout<<"角色当前状态："<<endl;
            cout<<"体力："<<this->vit<<endl;
            cout<<"攻击力："<<this->atk<<endl;
            cout<<"防御力："<<this->def<<endl;
        }

        //获得初始状态
        void GetInitState()
        {
            this->vit = 100;
            this->atk = 100;
            this->def = 100;
        }

        //战斗
        void Fight()
        {
            this->vit = 0;
            this->atk = 0;
            this->def = 0;
        }
    }; 
    
    
        int main()
        {
            //大战Boss前
            GameRole *lixiaoyao = new GameRole();
            lixiaoyao->GetInitState();
            lixiaoyao->StateDisplay();

            //保存进度
            GameRole *backup = new GameRole();
            backup->setVitality(lixiaoyao->getVitality());
            backup->setAttack(lixiaoyao->getAttack());
            backup->setDefense(lixiaoyao->getDefense());

            //大战Boss时，损耗严重
            lixiaoyao->Fight();
            lixiaoyao->StateDisplay();

            //恢复之前状态
            lixiaoyao->setVitality(backup->getVitality());
            lixiaoyao->setAttack(backup->getAttack());
            lixiaoyao->setDefense(backup->getDefense());
            

            lixiaoyao->StateDisplay();
        }

2）备忘录模式

优点：客户端隐藏了实现细节。

#include <iostream>
using namespace std; 

    //角色状态存储箱
    class RoleStateMemento
    {
        private: int vit;
                 int atk;
                  int def;

        public:
		  RoleStateMemento(int vit, int atk, int def)
        {
            this->vit = vit;
            this->atk = atk;
            this->def = def;
        }

        //生命力

		   int getVitality() 
        {
           return vit; 
	     }
	     
         void   setVitality(int value) 
		  { 
		     this->vit = value; 
         }
        

        //攻击力       
	
		   int getAttack() 
    	   {
            	return atk; 
       	   } 
          void setAttack(int value) 
          {
		   		this->atk = value; 
		  }
        

        //防御力
        int getDefense() 
        {
        	 return def;
       	} 
         void setDefense(int value) 
        {
        	 this->def = value;
       	} 
    }; 
    
  class GameRole
  {
	  //生命力
        private:
		   int vit;
        
        public:
		   int getVitality() 
        {
           return vit; 
	     }
	     
         void   setVitality(int value) 
		  { 
		     this->vit = value; 
         }
        

        //攻击力
        private:
		    int atk;
        public:
		   int getAttack() 
    	   {
            	return atk; 
       	   } 
          void setAttack(int value) 
          {
		   		this->atk = value; 
		  }
        

        //防御力
        private:
		   int def;
        public: 
        int getDefense() 
        {
        	 return def;
       	} 
         void setDefense(int value) 
        {
        	 this->def = value;
       	} 
         

        //状态显示
        void StateDisplay()
        {
            cout<<"角色当前状态："<<endl;
            cout<<"体力："<<this->vit<<endl;
            cout<<"攻击力："<<this->atk<<endl;
            cout<<"防御力："<<this->def<<endl;
        }


        //保存角色状态
        RoleStateMemento *SaveState()
        {
            return (new RoleStateMemento(vit, atk, def));
        }

        //恢复角色状态
        void RecoveryState(RoleStateMemento *memento)
        {
            this->vit = memento->getVitality();
            this->atk = memento->getAttack();
            this->def = memento->getDefense();
        }


        //获得初始状态
         void GetInitState()
        {
            this->vit = 100;
            this->atk = 100;
            this->def = 100;
        }

        //战斗
         void Fight()
        {
            this->vit = 0;
            this->atk = 0;
            this->def = 0;
        }
    }; 



    //角色状态管理者
    class RoleStateCaretaker
    {
        private:
		    RoleStateMemento *memento;

        public:
		   RoleStateMemento* getMemento() 
          {
            return memento; 
          }
          void setMemento(RoleStateMemento *value) 
          { 
			 this->memento = value; 
           }
        
    }; 
 
        int main()
        {

            //大战Boss前
            GameRole *lixiaoyao = new GameRole();
            lixiaoyao->GetInitState();
            lixiaoyao->StateDisplay();

            //保存进度
            RoleStateCaretaker *stateAdmin = new RoleStateCaretaker();
            stateAdmin->setMemento(lixiaoyao->SaveState());

            //大战Boss时，损耗严重
            lixiaoyao->Fight();
            lixiaoyao->StateDisplay();

            //恢复之前状态
            lixiaoyao->RecoveryState(stateAdmin->getMemento());

            lixiaoyao->StateDisplay();



        }