设计模式 备忘录模式

1、memento.h

#ifndef MEMENTO_H
#define MEMENTO_H

#include <iostream>
#include <vector>
using namespace std;

class Memento;
class Employee //原发器（Originator）,创建一个备忘录. 用以记录当前时刻它的内部状态.使用备忘录恢复内部状态.
{
public:
    Employee();
    virtual ~Employee();
    void SetId(int);
    int GetId();
    char* GetName();
    void SetName(char*);
    void SetSalary(double);
    double GetSalary();
    void SetMemento(Memento*);
    Memento* GetMemento();
    friend std::ostream& operator<<(std::ostream& os, Employee& employee);
private:
    int m_nId;
    char* m_pName;
    double m_dSalary;
};

class Memento //Memento(备忘录),存储原发器对象的内部状态,防止原发器以外的对象访问备忘录.
{
public:
    Memento(int, char*, double);
    virtual ~Memento();
    friend class Employee;//声明为友元类，可以访问这个类的成员变量，就是说，在Employee成员函数中有Memento对象，
                          //则，可以引用Memento对象的私有变量，如m_nId
private:
    int m_nId;
    char* m_pName;
    double m_dSalary;
};

class Caretaker //看管者（caretaker）,负责保存好备忘录,不能对备忘录的内容操作或检查.
{
public:
    Caretaker(Employee*);
    virtual ~Caretaker();
    void SaveEmployee();
    void UnsaveEmployee();
private:
    std::vector<Memento*> m_vMementos;
    Employee* m_pEmployee;
};

#endif // MEMENTO_H

2、memento.cpp

#include "memento.h"


Employee::Employee(){}

Employee::~Employee(){}

void Employee::SetId(int nId)
{
    m_nId = nId;
}

int Employee::GetId()
{
    return m_nId;
}

void Employee::SetName(char* pName)
{
    m_pName = pName;
}

char* Employee::GetName()
{
    return m_pName;
}

void Employee::SetSalary(double dSalary)
{
    m_dSalary = dSalary;
}

double Employee::GetSalary()
{
    return m_dSalary;
}

void Employee::SetMemento(Memento* pMemento)
{
    m_nId = pMemento->m_nId;
    m_pName = pMemento->m_pName;
    m_dSalary = pMemento->m_dSalary;
}

Memento* Employee::GetMemento()
{
    return new Memento(m_nId, m_pName, m_dSalary);
}

std::ostream& operator<<(std::ostream& os, Employee& employee)
{
    return os << "ID：" << employee.m_nId << ", "
            << "Name：" << employee.m_pName << ", "
            << "Salary：" << employee.m_dSalary << endl;
}

Memento::Memento(int nId, char* pName, double dSalary)
{
    m_nId = nId;
    m_pName = pName;
    m_dSalary = dSalary;
}

Memento::~Memento(){}

Caretaker::Caretaker(Employee* pEmployee)
{
    m_pEmployee = pEmployee;
}

Caretaker::~Caretaker()
{
    if(m_pEmployee != NULL)
    {
        delete m_pEmployee;
        m_pEmployee = NULL;
    }
}

void Caretaker::SaveEmployee()
{
    Memento* pMemento = m_pEmployee->GetMemento();
    m_vMementos.push_back(pMemento);
}

void Caretaker::UnsaveEmployee()
{
    if(m_vMementos.size() > 0)
    {
        Memento* pMemento = m_vMementos.at(m_vMementos.size() - 1);
        m_vMementos.pop_back();
        m_pEmployee->SetMemento(pMemento);
    }
}

3、main.cpp

/*
作者：jhluroom弹   QQ：454676244  MSN：jhlu0815@hotmail.com
开发IDE：qt creater
开发环境：QT C++
参考网站：神秘果：http://www.shenmiguo.com/

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


理解：
1.备忘录（Memento）角色：备忘录角色存储“备忘发起角色”的内部状态。“备忘发起角色”根据需要决定备忘录角色存储“备忘发起角色”
  的哪些内部状态。为了防止“备忘发起角色”以外的其他对象访问备忘录。备忘录实际上有两个接口，“备忘录管理者角色”只能看到备忘录
  提供的窄接口——对于备忘录角色中存放的属性是不可见的。“备忘发起角色”则能够看到一个宽接口——能够得到自己放入备忘录角色中属性。
2.备忘发起（Originator）角色：“备忘发起角色”创建一个备忘录，用以记录当前时刻它的内部状态。在需要时使用备忘录恢复内部状态。
3.备忘录管理者（Caretaker）角色：负责保存好备忘录。不能对备忘录的内容进行操作或检查。

要点：
1.备忘录模式（Memento）的定义为：在不破坏封闭的前提下，捕获并保存一个对象的内部状态，这样可以将对象恢复到原先的状态。
2.很多应用程序中的Ctrl+Z会取消最后一次用户操作，如果不用备忘模式，看管者（caretaker）对象要备份原发器（Originator）
  对象状态，并且要清楚原发器内部的结构，这样在原发器上的任何修改，看管者都要做相应的修改，使用备记录模式可以解决这种问题，
  备忘录封闭保存备份的状态，当原发器提出备份请求，它就会创建一个备忘录对象返回给看者。
3.Memento模式中封装的是需要保存的状态，当需要恢复的时候才取出来进行恢复。原理很简单，实现的时候需要注意一个地方：
  窄接口和宽接口。
  宽接口，就是一般意义上的接口，把对外的接口作为public成员；
  窄接口，把接口作为private成员，而把需要访问这些接口函数的类作为这个类的友元类，也就是说接口只暴露给了对这些接口感兴趣的类，
  而不是暴露在外部。

应用：
1.需要保存一个对象在某时刻的状态.以备以后恢复.
2.保存状态时不想让其它对象直接得到对象内部的实现细节。
3.假设有一雇员信息，我们可对其进行修改，当多次修改后，想撤消回原来的状态，这时可以用备忘录模式对雇员信息进行备份，
  需要还原时就可对其进行撤消操作。如下面程序所示：

以上文字说明，从网上整理而来，有可能部分与其他同仁相同，请谅解，希望我们能够共同交流，谢谢！
*/

#include <QtCore/QCoreApplication>

#include "memento.h"

int main(int argc, char *argv[])
{
    cout << "=== jhluroom start ========" << endl;

    Employee* pEmployee = new Employee();
    Caretaker* pCaretaker = new Caretaker(pEmployee);

    pEmployee->SetId(1);
    pEmployee->SetName("xiao li");
    pEmployee->SetSalary(6000.00);
    pCaretaker->SaveEmployee();
    cout <<"撤消前: "<< *pEmployee;

    pEmployee->SetId(2);
    pEmployee->SetName("xiao wang");
    pEmployee->SetSalary(8000.00);
    pCaretaker->SaveEmployee();
    cout <<"撤消前: "<< *pEmployee;

    pEmployee->SetId(3);
    pEmployee->SetName("xiao lu");
    pEmployee->SetSalary(15000.00);
    pCaretaker->SaveEmployee();
    cout <<"撤消前: "<< *pEmployee;

    pCaretaker->UnsaveEmployee();
    cout << "撤消后: " << *pEmployee;
    pCaretaker->UnsaveEmployee();
    cout << "撤消后: " << *pEmployee;
    pCaretaker->UnsaveEmployee();
    cout << "撤消后: " << *pEmployee;

    cout << "=== jhluroom finish _^_ ===" << endl;
    return 0;
}

运行结果：

=== jhluroom start ========

撤消前: ID：1, Name：xiao li, Salary：6000
撤消前: ID：2, Name：xiao wang, Salary：8000
撤消前: ID：3, Name：xiao lu, Salary：15000
撤消后: ID：3, Name：xiao lu, Salary：15000
撤消后: ID：2, Name：xiao wang, Salary：8000
撤消后: ID：1, Name：xiao li, Salary：6000

=== jhluroom finish _^_ ===