备忘录模式（C++实现）

（本博客旨在个人总结回顾）

1、详情：

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

说明：

优点： 

①给用户提供了一种可以恢复状态的机制，可以使用户能够比较方便地回到某个历史的状态。

②实现了信息的封装，使得用户不需要关心状态的保存细节。

缺点：

消耗资源。如果类的成员变量过多，势必会占用比较大的资源，而且每一次保存都会消耗一定的内存。

使用场景： 

①需要保存/恢复数据的相关状态场景。

②提供一个可回滚的操作。

注意事项： 

①为了符合迪米特原则，还要增加一个管理备忘录的类。

②为了节约内存，可使用原型模式+备忘录模式。

2.1、UML类图：

 

2.2、例子源码

stdafx.h

// stdafx.h : 标准系统包含文件的包含文件，
// 或是经常使用但不常更改的
// 特定于项目的包含文件
//

#pragma once

#include "targetver.h"

#include <stdio.h>
#include <tchar.h>

#include <iostream>
using namespace std;

// TODO:  在此处引用程序需要的其他头文件

Memento.h

#pragma once

class Memento
{
public:
    Memento(string strState);
    ~Memento();

public:
    string GetState();

private:
    string m_strState;
};

Memento.cpp

#include "stdafx.h"
#include "Memento.h"

Memento::Memento(string strState)
    : m_strState(strState)
{
}

Memento::~Memento()
{
}

std::string Memento::GetState()
{
    return m_strState;
}

Caretaker.h

#pragma once
#include "Memento.h"
#include <map>

class Caretaker
{
public:
    Caretaker();
    ~Caretaker();

public:
    void SetMemento(int key, Memento* pMemento);
    Memento* GetMemento(int key);

private:
    map<int, Memento*> m_mapMemento;
};

Caretaker.cpp

#include "stdafx.h"
#include "Caretaker.h"

Caretaker::Caretaker()
{
}

Caretaker::~Caretaker()
{
    for (map<int, Memento*>::iterator it = m_mapMemento.begin(); it != m_mapMemento.end(); it++)
    {
        delete it->second;
    }
    m_mapMemento.clear();
}

void Caretaker::SetMemento(int key, Memento* pMemento)
{
    if (m_mapMemento.find(key) != m_mapMemento.end())
    {
        delete m_mapMemento[key];
    }
    m_mapMemento[key] = pMemento;
}

Memento* Caretaker::GetMemento(int key)
{
    if (m_mapMemento.find(key) != m_mapMemento.end())
    {
        return m_mapMemento[key];
    }
    return NULL;
}

Originator.h

#pragma once
#include "Memento.h"

class Originator
{
public:
    Originator();
    ~Originator();

public:
    void SetState(string strState);
    string GetState();
    Memento* CreateMemento();
    void SetMemento(Memento* pMemento);
    void Show();

private:
    string m_strState;
};

Originator.cpp

#include "stdafx.h"
#include "Originator.h"

Originator::Originator()
    : m_strState("")
{
}

Originator::~Originator()
{
}

void Originator::SetState(string strState)
{
    m_strState = strState;
}

std::string Originator::GetState()
{
    return m_strState;
}

Memento* Originator::CreateMemento()
{
    return new Memento(m_strState);
}

void Originator::SetMemento(Memento* pMemento)
{
    m_strState = pMemento->GetState();
}

void Originator::Show()
{
    cout << "State:" << m_strState.c_str()  << endl; 
}

调用代码

MementoPatternMemo.cpp

// MementoPatternMemo.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "Originator.h"
#include "Memento.h"
#include "Caretaker.h"

int _tmain(int argc, _TCHAR* argv[])
{
    Originator* pOriginator = new Originator();
    pOriginator->SetState("初始状态");
    pOriginator->Show();

    Caretaker* pCaretaker = new Caretaker();
    pCaretaker->SetMemento(0, pOriginator->CreateMemento());

    pOriginator->SetState("状态1");
    pOriginator->Show();

    pCaretaker->SetMemento(1, pOriginator->CreateMemento());

    pOriginator->SetMemento(pCaretaker->GetMemento(0));
    pOriginator->Show();

    pOriginator->SetMemento(pCaretaker->GetMemento(1));
    pOriginator->Show();

    system("pause");
	return 0;
}

2.3、运行结果：