C++設計模式-Memento備忘錄模式

Memento模式
作用：在不破壞封裝性的前提下，捕獲一個對象的內部狀態，並在該對象之外保存這個狀態，這樣以后就可將該對象恢復到原先保存的狀態。

UML圖：

Originator：負責創建一個備忘錄Memento，用以記錄當前時刻它的內部狀態，並可使用備忘錄恢復內部狀態。Originator可根據需要決定Memento存儲Originator的哪些內部狀態。

Memento:負責存儲Originator對象的內部狀態，並可防止Originator以外的其他對象訪問備忘錄Memento。備忘錄有兩個接口，Caretaker只能看到備忘錄的窄接口，它只能將備忘錄傳遞給其他對象。Originator能夠看到一個寬接口，允許它訪問返回到先前狀態所需的所有數據。

Caretaker：負責保存好備忘錄Memento,不能對備忘錄的內容進行操作或檢查。

Memento模式中封裝的是需要保存的狀態,當需要恢復的時候才取出來進行恢復.原理很簡單,實現的時候需要注意一個地方:窄接口和寬接口.所謂的寬接口就是一般意義上的接口,把對外的接口作為public成員;而窄接口反之,把接口作為private成員,而把需要訪問這些接口函數的類作為這個類的友元類,也就是說接口只暴露給了對這些接口感興趣的類,而不是暴露在外部.下面的實現就是窄實現的方法來實現的.

Memento模式比較適用於功能比較復雜的，但需要維護或記錄歷史屬性的類，或者需要保存的屬性只是眾多屬性中的一小部分時，Originator可以根據保存的Memento信息還原到前一狀態。

如果在某個系統中使用命令模式時，需要實現命令的撤銷功能，那么命令模式可以使用備忘錄模式來存儲可撤銷操作的狀態。

代碼如下：

Memento.h

#ifndef _MEMENTO_H_
#define _MEMENTO_H_
#include <string>

using namespace std;

//負責存儲Originator對象的內部狀態，並可防止Originator以外的其他對象訪問備忘錄Memento。
//備忘錄有兩個接口，Caretaker只能看到備忘錄的窄接口，它只能將備忘錄傳遞給其他對象。Originator能夠看到一個寬接口，允許它訪問返回到先前狀態所需的所有數據。
class Memento
{
private:
    //將Originator為friend類，可以訪問內部信息，但是其他類不能訪問
    friend class Originator;
    Memento(const string& state);
    ~Memento();
    void SetState(const string& state);
    string GetState();
    string _state;
};

//負責創建一個備忘錄Memento，用以記錄當前時刻它的內部狀態，並可使用備忘錄恢復內部狀態
class Originator
{
public:
    Originator();
    Originator(const string& state);
    ~Originator();
    void RestoreToMemento(Memento* pMemento);
    Memento* CreateMemento();
    void SetState(const string& state);
    string GetState();
    void show();
protected:
private:
    string _state;
};

//負責保存好備忘錄Memento,不能對備忘錄的內容進行操作或檢查
class Caretaker
{
public:
    Caretaker();
    ~Caretaker();
    void SetMemento(Memento*);
    Memento* GetMemento();
private:
    Memento* _memento;
};

#endif

Memento.cpp

#include "Memento.h"
#include <iostream>
#include <string>

using namespace std;

Memento::Memento(const string& state)
{
    this->_state = state;
}

Memento::~Memento()
{}

string Memento::GetState()
{
    return this->_state;
}

void Memento::SetState(const string& state)
{
    this->_state = state;
}

Originator::Originator()
{}

Originator::Originator(const string& state)
{
    this->_state = state;
}

Originator::~Originator()
{}

string Originator::GetState()
{
    return this->_state;
}

void Originator::show()
{
    cout << this->_state << endl;
}

void Originator::SetState(const string& state)
{
    this->_state = state;
}

Memento* Originator::CreateMemento()
{
    return new Memento(this->_state);
}

void Originator::RestoreToMemento(Memento* pMemento)
{
    this->_state = pMemento->GetState();
}

Caretaker::Caretaker()
{}

Caretaker::~Caretaker()
{}

Memento* Caretaker::GetMemento()
{
    return this->_memento;
}

void Caretaker::SetMemento(Memento* pMemento)
{
    this->_memento = pMemento;
}

main.cpp

#include "Memento.h"

int main()
{
    //初始化對象，狀態為“Old”
    Originator* o = new Originator("Old");
    o->show();

    //建立並保存Memento
    Caretaker* pTaker = new Caretaker();
    pTaker->SetMemento(o->CreateMemento());

    //改變狀態
    o->SetState("New");
    o->show();

    //恢復狀態
    o->RestoreToMemento(pTaker->GetMemento());
    o->show();

    return 0;
}

結果如下：