设计模式笔记--行为型模式之六--Memento 备忘录

 

意图：

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

 

适用性：

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

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

 

效果：

1保持封装边界   使用备忘录可以避免暴露一些只应由原发器管理却又必须储存在原发器之外的信息。

2简化了原发器   让客户管理它们请求的状态会简化Originator,并且使得客户工作结束时无需通知原发器

3使用 Memento可能代价很高  如果原发器在生成备忘录时必须拷贝并储存大量的信息，或者客户非常频繁地创建备忘录，可能会导致非常大的开销

4定义宽接口和窄接口

 

实现：

1语言支持  Memento有两个接口，一个为原发器所使用的宽接口，一个为其它对象所使用的窄接口。在C++中，可将Originator作为Memento的一个友元，并使接口为私有。只有窄接口被声明为公共的。

2存储式增量改变

如果备忘录的创建及返回的顺序是可测的，备忘录可以仅存储原发器内部状态的增量改变

 

 

The code is below.

Memento.h

1. #include <string>
2. #include <iostream>
3. using namespace std;
4. #define MAX_NUM 30
5. class Point
6. {
7. public:
8.     Point(int x, int y):_x(x),_y(y)
9.     {
10.       cout<<"Create a point, x is" <<_x<<", y is"<<_y<<endl;
11.     }
13. private:
14.     int _x,_y;
15. };
17. class ConstraintSolverMemento;
19. class MoveCommand
20. {
21. public:
22.     MoveCommand() 
23.     {cout<<"Create a move command"<<endl;
24.      for(int i=0;i<MAX_NUM;i++)
25.          _state[i]=0;
26.     }
27.     void Execute(string s);
28.     void Unexecute();
29. private:
30.     ConstraintSolverMemento* _state[MAX_NUM];
31.     //Point _delta;
32. };
35. class ConstraintSolver
36. {
37. public:
38.     static ConstraintSolver* Instance();
39.     void   solve() {cout<<"Solve it"<<endl;}
40.     void   AddConstraint()    {cout<<"Add constraint."<<endl;}
41.     void   RemoveConstraint() {cout<<"Remove constraint."<<endl;}
42.     ConstraintSolverMemento*   CreateMemento(string s);
43.     void SetMemento(ConstraintSolverMemento*);
44. private:
45.     static ConstraintSolver* _instance;
46. };
49. class ConstraintSolverMemento
50. {
51. public:
52.     virtual ~ConstraintSolverMemento(){cout<<"Destory ConstraintSolverMemento"<<endl;}
53.     string getstate(){return state;}
54. private:
55.     friend class ConstraintSolver;
56.     ConstraintSolverMemento(string s):state(s){}
57.     string state;
58. };

 

Memento.cpp

 

 

1. #include "Memento.h"
2. #include <iostream>
3. #include <string>
4. using namespace std;
5. ConstraintSolver* ConstraintSolver::_instance = 0;
6. Constrai ConstraintSolverMemento(s);
7. }
8. void ConstraintntSolver* ConstraintSolver::Instance()
9. {
10.     if (_instance == 0)
11.         _instance = new ConstraintSolver;
12.     return _instance;
13. }
14. ConstraintSolverMemento* ConstraintSolver::CreateMemento(string s)
15. {
16.     cout<<"Create Memento"<<endl;
17.     return newSolver::SetMemento(ConstraintSolverMemento* s)
18. {
19.     cout<<"Set Memento "<<s->getstate()<<endl;
20.     
21. }
23. void MoveCommand::Execute(string s)
24. {
25.     ConstraintSolver* solver = ConstraintSolver::Instance();
26.     for (int i=0;i<MAX_NUM;i++)
27.         if ( _state[i] == 0)
28.              break;
29.     if(i<MAX_NUM)
30.     {
31.      _state[i] =solver->CreateMemento(s);
32.      cout<<"Execute " << i<<endl;
33.     }
34.     solver->solve();
35. }
36. void MoveCommand::Unexecute()
37. {
38.     ConstraintSolver* solver = ConstraintSolver::Instance();
39.     for(int i=MAX_NUM-1;i>=0;i--)
40.         if(_state[i]!=0 )
41.             break;
42.     cout<<"unExecute " << i<<endl;
43.     if (i>=1)
44.      solver->SetMemento(_state[i-1]);
45.     else
46.       cout<<"Return back orginal state"<<endl;
47.     _state[i] = 0;
48.     solver->solve();
49. }

main.cpp

 

1. #include "Memento.h"
2. #include <iostream>
3. using namespace std;
4. int main()
5. {
6.     MoveCommand a;
7.     string s="down";
8.     a.Execute("down");
9.     a.Execute("up");
10.     a.Unexecute();
11.     a.Unexecute();
12.     return 0;
13. }