设计模式笔记-Memento模式

备忘录模式：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。备忘的用例很多，比如word编辑，按ctrl+z撤消，如果没备忘，肯定是不能撤消回到之前状态的；打过游戏的人应该也了解，比如DOTA1,技术挺落后，不像DOTA2断线可以重连，比赛的时候为了防止游戏崩溃，时不时的裁判要手动保存游戏。

这里的Memento类保存的是Originator类的一个临时状态，它自己是不可以变化的--本来就是要保存原来状态，又被改变了那不是没意义了？所以这里我把Memento类的所有成员都设为private的，然后把Originator设为友元类，这样它就只能被Originator访问了。这个应该是个关注点，但看网上好多人没有这么弄，成员函数都是public的，可能很多人觉得只要我不去调用它不就行了嘛，违反了迪米特法则？“一个对象应该对其他对象保持最少的了解”，这就是设计的精妙。

还有一点就是：为了在Originator类中创建备忘，设计了备忘类Memento的一个带Originator*类型参数的拷贝构造函数！

//originator.h

#include<string>
#include "memento.h"

class Memento;
class Originator {
public:
	Memento* createMemento();

	void restoreMemento(Memento *);

	void setState(string state)	{
		_state = state;
	}
	string getState() {
		return _state;
	}
private:
	std::string _state;
};

//originator.cpp

void Originator::restoreMemento(Memento *m) {
	_state = m->getState();
}
Memento* Originator::createMemento() {
	return new Memento(this);
}

//memento.h
#include"originator.h"
#include<string>

class Originator;
class Memento {
	friend class Originator;
private:
	Memento(Originator*);

	void setState(std::string state) {
		_state = state;
	}
	std::string getState() {
		return _state;
	}

private:
	std::string _state;
};

//memento.cpp
#include "memento.h"
Memento::Memento(Originator *o) {
	_state = o->getState();
}

完全可以不用Caretaker类，此时用户代码需要自己处理备份多状态逻辑(用容器)。 简单的实现如下：

class Caretaker {
	void Save(Memento *lpMemento) {
		m_vectMemento.push_back(lpMemento);
	}

	Memento* Load(int idx) {	//这里随便你怎么实现吧
		return m_vectMemento[idx];
	}

private:
	vector<Memento*> m_vectMemento;
};

用户代码：

int main()
{
	Originator originator;
	originator.setState("old");
	Memento * meme = originator.createMemento();
	originator.setState("new");
	originator.restoreMemento(meme);

	//使用Caretaker类也可以
	Originator originator;
	Caretaker take;
	originator.setState("old");
	Memento * meme = originator.createMemento();
	take.Save(meme);
	originator.setState("new");
	originator.restoreMemento(take.Load(0));
	return 0;
}