A brief understanding of C++ design patterns memo pattern

Memento mode: Capture the internal state of an object and save this state outside the object without destroying encapsulation. This allows you to later restore the object to its original saved state.

Pattern implementation:

[code]struct State{
    wchar_t wcsState[260];
};

class Memento{
public:
    Memento(State *pState): m_pState(pState) {}
    State *GetState() { return m_pState; }

private:
    friend class Originator;

    State *m_pState;
};

class Originator{
public:
    Originator() : m_pState(NULL) {}
    ~Originator(){
        //Delete the storage of the state
        if(m_pState){
            delete m_pState;
            m_pState = NULL;
        }
    }

    void SetMemento(Memento *pMemento);

    Memento * CreateMemento();

    void SetValue(wchar_t *val){
        memset(wcsValue, 0, 260 * sizeof(wchar_t));
        wcscpy_s(wcsValue, 260, val);
    }

    void PrintState() { std::wcout << wcsValue << std::endl; } 

private:
    State *m_pState; //To store the object&#39;s state
    wchar_t wcsValue[260]; //This is the object&#39;s real data
};

Memento *Originator::CreateMemento(){
    m_pState = new State;
    if(m_pState == NULL)
        return NULL;
    Memento *pMemento = new Memento(m_pState);

    wcscpy_s(m_pState->wcsState, 260, wcsValue);  //Backup the value

    return pMemento;
}

void Originator::SetMemento(Memento *pMemento){
    m_pState = pMemento->GetState();
    //Recovery the data
    memset(wcsValue, 0, 260 * sizeof(wchar_t));
    wcscpy_s(wcsValue, 260, m_pState->wcsState);
}

//Manager the Memento
class Caretaker{
public:
    Memento *GetMemento() { return m_pMemento; }
    void SetMemento(Memento *pMemento){
        //Free the previous Memento
        if(m_pMemento){
            delete m_pMemento;
            m_pMemento = NULL;
        }

        //set the new Memento
        m_pMemento = pMemento;
    }
private:
    Memento *m_pMemento;
};

Client:

[code]int main(){ 
    Originator *pOriginator = new Originator();
    pOriginator->SetValue(L"on");
    pOriginator->PrintState();  //OutPut： on

    //Now I backup the state
    Caretaker *pCaretaker = new Caretaker();
    pCaretaker->SetMemento(pOriginator->CreateMemento());

    //Set the new state
    pOriginator->SetValue(L"off");
    pOriginator->PrintState(); //OutPut： off

    //Recovery to the old state
    pOriginator->SetMemento(pCaretaker->GetMemento());
    pOriginator->PrintState(); //OutPut： on

    if(pCaretaker)
        delete pCaretaker;
    if(pOriginator);
        delete pOriginator;
    return 0;
}

The above is the content of C++ design pattern brief understanding memo pattern, please pay attention to more related content PHP Chinese website (www.php.cn)!