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

Memento模式中封装的是需要保存的状态，当需要恢复的时候才取出来进行恢复。原理很简单，实现的时候需要注意一个地方：窄接口和宽接口。所谓的宽接口就是一般意义上的接口，把对外的接口作为public成员；而窄接口反之，把接口作为private成员，而把需要访问这些接口函数的类作为这个类的友元类，也就是说接口只暴露给了对这些接口感兴趣的类，而不是暴露在外部。下面的实现就是窄实现的方法来实现的。

 1 
 2 #include "Memento.h"
 3 #include <iostream>
 4 
 5 Originator::Originator()
 6 {
 7 
 8 }
 9 
10 Originator::Originator(const State& rState)
11     : m_State(rState)
12 {
13 
14 }
15 
16 Originator::~Originator()
17 {
18 
19 }
20 
21 State Originator::GetState()
22 {
23     return m_State;
24 }
25 
26 void Originator::SetState(const State& rState)
27 {
28     m_State = rState;
29 }
30 
31 Memento* Originator::CreateMemento()
32 {
33     return new Memento(m_State);
34 }
35 
36 void Originator::RestoreState(Memento* pMemento)
37 {
38     if (NULL != pMemento)
39     {
40         m_State = pMemento->GetState();
41     }    
42 }
43 
44 void Originator::PrintState()
45 {
46     std::cout << "State = " << m_State << std::endl;
47 }
48 
49 Memento::Memento(const State& rState)
50     : m_State(rState)
51 {
52 
53 }
54 
55 State Memento::GetState()
56 {
57     return m_State;
58 }
59 
60 void Memento::SetState(const State& rState)
61 {
62     m_State = rState;
63 }

 1 
 2 #include "Memento.h"
 3 
 4 int main()
 5 {
 6     // 创建一个原发器
 7     Originator* pOriginator = new Originator("old state");
 8     pOriginator->PrintState();
 9 
10     // 创建一个备忘录存放这个原发器的状态
11     Memento *pMemento = pOriginator->CreateMemento();
12     
13     // 更改原发器的状态
14     pOriginator->SetState("new state");
15     pOriginator->PrintState();
16 
17     // 通过备忘录把原发器的状态还原到之前的状态
18     pOriginator->RestoreState(pMemento);
19     pOriginator->PrintState();
20 
21     delete pOriginator;
22     delete pMemento;
23 
24     return 0;
25 }