轉載自：
http://patmusing.blog.163.com/blog/static/13583496020101501825958/
Aka. Token
在不破壞封裝性的前提下，捕獲一個對象的內部狀態，并在該對象之外保存其狀態。這樣以后就可以將該對象恢復到原先保存的狀態。
“Without violating encapsulation, capture and externalize an object’s internal state so that the object can be restored to this state later.” – GoF
動機
有時候需要記錄一個對象的內部狀態。比如要實現checkpoint或者undo這樣的機制，可以讓使用者從臨時性的操作跳出來或者需要修復錯誤的時候，你必須將狀態信息保存在某個地方，以便在進行某些操作后，將對象恢復到原來的狀態。但通常情況下，對象封裝了狀態(即私有成員變量)，因此其他的對象無法訪問這些狀態，而且也不可能將這些狀態保存在對象之外。如果將這些狀態設置成公有的，又會違反面向對象封裝性的原則，同時也會削弱應用的可靠性和可擴展性。
在軟件構建過程中， 某些對象的狀態在轉換過程中，可能由于某種需要，要求程序能夠回溯到對象之前處于某個時刻的狀態。如果使用一些共有接口來讓其他對象得到對象的狀態，便會暴露對象的細節實現。Memento設計模式就可以實現對象狀態的良好保存與恢復，但同時又不會因此而破壞對象本身的封裝性。
UML類圖：
角色
- Memento
1. 保存Originator對象的內部狀態。
2. 除Originator外，其他對象均不能訪問Memento對象。
- Originator
1. 創建一個包含其當前內部狀態快照的Memento對象。
2. 使用Memento對象來恢復其內部狀態。
- Caretaker
1. Memento對象的容器。在C++中一般用stack來實現。
2. 從不對Memento對象的內容進行檢查或操作。
示例代碼：
// Memento.h
#include <iostream>
#include <stack>
using namespace std;
// CMemento類，用來保存CRectangle的狀態
class CMemento
{
private: // 所有的成員變量和成員函數都是私有的
int topx; // 因此除友元類CRectangle外，其他對象都無法訪問
int topy;
int width;
int height;
private:
CMemento()
{
}
//private: // 1. 如果編寫了顯式拷貝構造函數，那么，它必須是公有的，
// CMemento(const CMemento& memo) // 否則CMementoStack將無法調用該拷貝構造函數。
// { // 2. 如果沒有顯式的拷貝構造函數，那么缺省的拷貝構造函數總是公有的。
// topx = memo.topx; // 3. 在Memento模式中，如果僅考慮保存一次狀態，則
// topy = memo.topy; // CMementoStack是不必要的，那么拷貝構造函數，可以
// width = memo.width; // 顯式地聲明為private的，盡管在CRectangle的create_memento
// height = memo.height; // 成員函數中也會調用CMemento的拷貝構造函數，但CRectangle
// } // 是CMemento的友元類，因此不存在這方面的限制。
private:
void set_state(int topx, int topy, int width, int height) // 保存CRectangle的狀態
{
this->topx = topx;
this->topy = topy;
this->width = width;
this->height = height;
}
friend class CRectangle; // 友元類CRectangle，可以訪問CMemento中的所有內容
};
// CRectangle類。一個矩形，需要保存狀態改變的類
class CRectangle
{
private:
int topx; // 矩形左上角的x坐標
int topy; // 矩形左上角的y坐標
int width; // 矩形的寬
int height; // 矩形的高
public:
CRectangle(int topx, int topy, int width, int height):topx(topx), topy(topy), width(width), height(height)
{
}
// 模擬移動矩形的位置到指定的點，即改變了矩形的狀態
void move_to(int topx, int topy)
{
this->topx = topx;
this->topy = topy;
}
// 模擬改變矩形的長和寬，即改變了矩形的狀態
void change_width_height(int width, int height)
{
this->width = width;
this->height = height;
}
// 將矩形恢復到memo中所保存的狀態
void set_memento(CMemento memo)
{
this->topx = memo.topx;
this->topy = memo.topy;
this->width = memo.width;
this->height = memo.height;
}
// 將矩形的狀態保存到一個CMemento對象
CMemento create_memento()
{
CMemento cm;
cm.set_state(this->topx, this->topy, this->width, this->height);
return cm;
}
// 輸出矩形的狀態信息
void print_info()
{
cout << "Top left point's x coordinate: " << topx << endl;
cout << "Top left point's y coordinate: " << topy << endl;
cout << "The width is: " << width << endl;
cout << "The height is: " << height << endl;
}
};
// CMemento對象的容器，可以用來保存多個CMemento對象，通常用stack來實現
class CMementoStack
{
private:
stack<CMemento> stk;
public:
void add_memento(CMemento memo)
{
stk.push(memo); //將CMemento對象壓入棧中
}
CMemento get_memento()
{
CMemento cm = stk.top(); // 取得CMemento對象。這個過程會用到CMemento類的拷貝構造函數，
// 由于CMemento對象中的成員變量均是普通類型(非指針、非類對象)，
// 因此使用默認的拷貝構造函數即可
stk.pop(); // 刪除已經取得的CMemento對象
return cm;
}
};
// Memento.cpp
#include "Memento.h"
int main(int argc, char **argv)
{
CRectangle cr(10, 10, 100, 100);
CMementoStack cs;
cout << "Initial states: " << endl;
cr.print_info();
CMemento cm0 = cr.create_memento(); // 將狀態保存到CMemento對象
cs.add_memento(cm0); // 將CMemento對象壓棧
// 第一次改變狀態
cr.change_width_height(200, 200); // 改變矩形的高度和寬度
cr.move_to(20, 20); // 改變矩形的位置
cout << "\nAfter 1st states changed: " << endl;
cr.print_info();
CMemento cm1 = cr.create_memento(); // 將狀態保存到CMemento對象
cs.add_memento(cm1); // 將CMemento對象壓棧
// 第二次改變狀態
cr.change_width_height(300, 300); // 改變矩形的高度和寬度
cr.move_to(30, 30); // 改變矩形的位置
cout << "\nAfter 2nd states changed: " << endl;
cr.print_info();
// ... 這里不再壓棧
// 恢復到第一次狀態的改變
cr.set_memento(cs.get_memento());
cout << "\nStates restored to 1st change: " << endl;
cr.print_info();
// 恢復到初始狀態
cr.set_memento(cs.get_memento());
cout << "\nStates restored to initial: " << endl;
cr.print_info();
}
運行結果：
Initial states:
Top left point's x coordinate: 10
Top left point's y coordinate: 10
The width is: 100
The height is: 100
After 1st states changed:
Top left point's x coordinate: 20
Top left point's y coordinate: 20
The width is: 200
The height is: 200
After 2nd states changed:
Top left point's x coordinate: 30
Top left point's y coordinate: 30
The width is: 300
The height is: 300
States restored to 1st change:
Top left point's x coordinate: 20
Top left point's y coordinate: 20
The width is: 200
The height is: 200
States restored to initial:
Top left point's x coordinate: 10
Top left point's y coordinate: 10
The width is: 100
The height is: 100
結果符合預期。
補充說明：
1. 未設置其成員變量為public的前提下，在對象的外部保存一個其狀態，頗需技巧，而且用不同語言來實現的時候也有所不同。
a. 對于C++，通常使用友元類來實現。
b. 對于C#，使用internal關鍵字。
c. 對于Java，使用package protected訪問控制。
與其處于相同包中的子類，和處于相同包中的其它類均可以訪問pakcage protected的對象或變量。
Java中的訪問權限有public,private,protected和默認的包訪問權限，如果類中的屬性方法沒有顯示的指明訪問權
限，則具有包訪問權限，很多人也稱它為friendly訪問權限，也有人稱為packeged權限，而packaged和friendly
這兩個關鍵字在實際中都是不存在的。在Java中，訪問權限修飾符權限從高到低是public，protected，package
protected，private。
d. C++, C#和Java均可使用內部類的方式來實現類似的功能，不過對于“將狀態存儲于對象之外”而言，稍嫌勉強。
2. 關于拷貝構造函數，請看：http://patmusing.blog.163.com/blog/static/1358349602009113061024796/
3. 關于友元類，請看：http://patmusing.blog.163.com/blog/static/1358349602010182331153/