设计模式之:备忘录模式

前言:

这个国庆,回家不想学习,于是下了个三国志11,玩了好几天,终于从一个只有一个城池,5、6个武将,一两万士兵的刘备,发展成占有半壁江山了,灭了曹操,袁绍等,那在玩游戏的时候,我肯定不能连续几十个小时都不退出游戏,或者说不关机,那我每次肯定都需要保存游戏进度才能下次继续玩,那这就用上我这次要说的备忘录模式了,每次讲记录保存在存档里,下次进入游戏又可以接着上一次继续玩了~

定义(源于GoF《设计模式》):

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

如何实现这个将状态信息保存在某处呢?使用原型模式?由于对象通常封装了其部分或所有的状态信息,使得其状态不能被其他对象访问,也就不可能在该对象之外保存其状态了。由于原型模式总是返回对象的全部状态信息,同时原型模式使其状态能被其它对象访问,这样就违反了封装的原则,还可能有损应用的可靠性和可扩展性。

一个备忘录是一个对象,它存储另一个对象在某个瞬间的所有状态,而后者称为备忘录的原发器。

当需要设置原发器的检查点时,取消操作机制会向原发器请求一个备忘录。原发器用描述当前状态的信息初始化该备忘录。

只有原发器可以向备忘录中存取信息,备忘录对其他的对象是“不可见”的。(通过友元来实现!)

关键点:

1、备份对象的状态;

2、不破坏封装!

UML图:(就如我所玩的游戏一样,一般游戏都有存档的限制,我这里设置了最多只能存档16个,当然每个都可以被覆盖!)

代码示例:

#include<iostream>
using namespace std;

class Memento              //备忘录中的原发器对象的内部状态
{

private:
	 friend class Originator;
	 Memento(int a,int b,int c):wujiangNum(a),chengchiNum(b),shibingNum(c){};
	int wujiangNum;     //武将数目
	int chengchiNum;	//城池数目
	int shibingNum;		//士兵数目

};

class Originator     //备忘录中的原发器,即需要备份的对象,利用Memento把对象的状态提取出来备份,而对象的函数方法等并不需要备份,只需备份状态
{
public:
	Originator()
	{

		this->wujiangNum=100;
		this->chengchiNum=100;
		this->shibingNum=100;

	};
	~Originator();
	void LoadState(Memento* memo){               //载入存档

		this->wujiangNum=memo->wujiangNum;
		this->chengchiNum=memo->chengchiNum;
		this->shibingNum=memo->shibingNum;

	}
	Memento* SaveState(){					//存档

		return new Memento(wujiangNum,chengchiNum,shibingNum);

	}

	void SometimeLater(){					//玩了一会之后,状态变化

		this->wujiangNum--;
		this->chengchiNum--;
		this->shibingNum--;

	}

	void showState(){					//展示状态

		cout<<this->wujiangNum<<endl<<this->chengchiNum<<endl<<this->shibingNum<<endl;

	}
private:
		int wujiangNum;     //武将数目
		int chengchiNum;	//城池数目
		int shibingNum;		//士兵数目

	/* data */
};

class Caretakerr  //备忘录模式中的,存档管理,就像游戏中的管理16个存档的对象
{
public:

	~Caretakerr()
	{

	};
	void SetStateMemento(Memento* pMemento,int index) { memento[index] = pMemento; }
	Memento *GetStateMemento(int index) { return memento[index] ; }

private:
	Memento* memento[16];

		/* data */
};

int main(int argc, char const *argv[])
{
	Originator* liubei=new Originator();//创建一个刘备
	Caretakerr pCaretaker;
	pCaretaker.SetStateMemento(liubei->SaveState(),1);       //存档到第一栏
	liubei->showState();

	liubei->SometimeLater();
	pCaretaker.SetStateMemento(liubei->SaveState(),2);      //一段时间后 存档到第二栏
	liubei->showState();

	liubei->LoadState(pCaretaker.GetStateMemento(1));		 //读取第一栏档
	liubei->showState();

	liubei->LoadState(pCaretaker.GetStateMemento(2));		 //读取第二栏档
	liubei->showState();

	liubei->SometimeLater();
	liubei->SometimeLater();
	pCaretaker.SetStateMemento(liubei->SaveState(),1);      //一段时间后 存档到第一栏
	liubei->LoadState(pCaretaker.GetStateMemento(1));		 //读取第一栏档
	liubei->showState();
}
时间: 2024-11-05 18:49:13

设计模式之:备忘录模式的相关文章

【设计模式】备忘录模式

备忘录模式:在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态.这样,以后就可以将该对象恢复到原先保存的状态.下面是一个用C++描述的备忘录模式的基本框架. #include <iostream> #include <string> using namespace std; // 备忘录 class Memento { public: // 保存数据 Memento(const string &str = "") { state

设计模式之备忘录模式(Memento)摘录

23种GOF设计模式一般分为三大类:创建型模式.结构型模式.行为模式. 创建型模式抽象了实例化过程,它们帮助一个系统独立于如何创建.组合和表示它的那些对象.一个类创建型模式使用继承改变被实例化的类,而一个对象创建型模式将实例化委托给另一个对象.创建型模式有两个不断出现的主旋律.第一,它们都将关于该系统使用哪些具体的类的信息封装起来.第二,它们隐藏了这些类的实例是如何被创建和放在一起的.整个系统关于这些对象所知道的是由抽象类所定义的接口.因此,创建型模式在什么被创建,谁创建它,它是怎样被创建的,以

大话设计模式_备忘录模式(Java代码)

备忘录模式:在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态.这样以后就可将该对象恢复到原先保存的状态. 简单描述:一个Memento类,代表Originator中要备份的属性.Originator负责生成备份和还原备份,CareTaker负责存储备份 大话设计模式中的截图: 例子代码: Memento类: 1 package com.longsheng.memento; 2 3 public class Memento { 4 5 private String sta

【设计模式】备忘录模式(以电影明日边缘为例)

1.说明 备忘录(Memento): 在不破坏封装性的前提下,捕获一个对象的内部装填,并在对象之外保存这个状态. 这样以后就可以将该对象恢复到原先保存的状态. 三个要素:[发起者] [备忘录] [管理者] 2.demo    电影明日边缘,阿汤哥被将军阁下扔到战场上,阿汤哥慢慢从基地醒来,迷迷糊糊到看见军队到处在走,头昏混沉沉到,后来阿汤哥还是被扔到里战场上, 可是阿汤哥每次挂掉以后都能从基地醒来那阵开始,因此种就相当于游戏里到备忘录,自动读档. [发起者] 阿汤哥[备忘录] 阿汤哥读档是到状态

折腾Java设计模式之备忘录模式

原文地址:折腾Java设计模式之备忘录模式 备忘录模式 Without violating encapsulation, capture and externalize an object's internal state allowing the object to be restored to this state later. 在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态. 所谓备忘录模式就是在不破坏封装的前提下,捕获一个对象的内部状态,并在该对象之外保存这个

【Unity与23种设计模式】备忘录模式(Memento)

GoF中定义: "在不违反封装的原则下,获取一个对象的内部状态并保留在外部,让对象可以在日后恢复到原先保留时的状态." 对于一些需要存储的数据,比如历史最高分 当与得分减分系统写入一个类时,违反了单一职责原则 最好是做一个SaveData的类单独存储或获取 而当使用一个单独的类时,又必须将数据public向外公开 这就将游戏置于危险的境地,甚至是方便了外挂横行 针对此矛盾局势 备忘录模式便解决了这一问题 备忘录模式可以描述为: 在不增加各个游戏系统类成员的"存取"方

Java设计模式之备忘录模式

本文继续23种设计模式系列之备忘录模式. 我们在编程的时候,经常需要保存对象的中间状态,当需要的时候,可以恢复到这个状态.比如,我们使用Eclipse进行编程时,假如编写失误(例如不小心误删除了几行代码),我们希望返回删除前的状态,便可以使用Ctrl+Z来进行返回.下象棋的时候,可以反悔.这时我们便可以使用备忘录模式来实现. 定义 在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态.这样就可以将该对象恢复到原先保存的状态 角色 发起人:记录当前时刻的内部状态,负责定义哪些

【GOF23设计模式】备忘录模式

来源:http://www.bjsxt.com/ 一.[GOF23设计模式]_备忘录模式.多点备忘.事务操作.回滚数据底层架构 1 package com.test.memento; 2 /** 3 * 源发器类 4 */ 5 public class Emp { 6 private String ename; 7 private int age; 8 private double salary; 9 10 //进行备忘操作,并返回备忘录对象 11 public EmpMemento memen

Head First设计模式之备忘录模式

一.定义 不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态.这样就可以将该对象恢复到原先保存的状态 二.结构 备忘录模式中主要有三类角色: 发起人角色:记录当前时刻的内部状态,负责创建和恢复备忘录数据. 备忘录角色:负责存储发起人对象的内部状态,在进行恢复时提供给发起人需要的状态. 管理者角色:负责保存备忘录对象,但是不能对备忘录对象的内容进行操作或检查. 三.适用场景 1.需要保存/恢复数据的相关状态场景. 2.提供一个可回滚的操作. 四.优缺点 优点: 1.给用户提供

【设计模式】—— 备忘录模式Memento

前言:[模式总览]——————————by xingoo 模式意图 这个模式主要是想通过一个对象来记录对象的某种状态,这样有利于在其他需要的场合进行恢复. 该模式还有跟多可以扩展的地方,比如可以记录多个时间的状态,每个角色都有可以扩展的空间,完全看业务场景而定. 应用场景 1 保存对象某一时刻的状态 2 避免直接暴露接口,破坏封装性 模式结构 Originator 是备忘录的发起者,记录状态的对象 class Originator{ private String state; public Me