设计模式专题之C语言-备忘录模式

1.简介

备忘录模式是一种行为设计模式，它允许在不破坏封装性的前提下捕获一个对象的内部状态，并且可以在以后将对象恢复到该状态。这种模式通常用于实现撤销功能、或者保存游戏进度等场景。

备忘录模式的基本结构

备忘器模式涉及到三个主要角色：

1. Originator（发起人）：维护一个备忘录对象，用以存储当前的状态。
2. Memento（备忘录）：负责存储发起人的内部状态，并防止发起人以外的对象访问这些状态。
3. Caretaker（管理者）：负责保存和提供备忘录对象，但不能对备忘录的内容进行操作。

2.通俗讲解

假设我们正在开发一个简单的文本编辑器，需要实现撤销功能。当用户输入文本后，可以撤销最后一次的修改。

3.实战

3.1.代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 定义备忘录结构体
typedef struct Memento {
    char *text; // 存储当前文本的状态
} Memento;

// 创建备忘录
Memento* createMemento(const char *text) {
    Memento *memento = (Memento*)malloc(sizeof(Memento));
    memento->text = strdup(text);
    return memento;
}

// 销毁备忘录
void destroyMemento(Memento *memento) {
    free(memento->text);
    free(memento);
}

// 定义发起人结构体
typedef struct Originator {
    char *text; // 当前的文本状态
} Originator;

// 创建发起人
Originator* createOriginator() {
    Originator *originator = (Originator*)malloc(sizeof(Originator));
    originator->text = NULL;
    return originator;
}

// 设置发起人的状态
void setOriginatorText(Originator *originator, const char *text) {
    if (originator->text) free(originator->text);
    originator->text = strdup(text);
}

// 获取发起人的状态
char* getOriginatorText(const Originator *originator) {
    return originator->text;
}

// 创建备忘录
Memento* saveToMemento(Originator *originator) {
    return createMemento(originator->text);
}

// 恢复状态
void restoreFromMemento(Originator *originator, Memento *memento) {
    setOriginatorText(originator, memento->text);
    destroyMemento(memento);
}

// 销毁发起人
void destroyOriginator(Originator *originator) {
    free(originator->text);
    free(originator);
}

// 定义管理者结构体
typedef struct Caretaker {
    Memento *memento; // 存储备忘录
} Caretaker;

// 创建管理者
Caretaker* createCaretaker() {
    Caretaker *caretaker = (Caretaker*)malloc(sizeof(Caretaker));
    caretaker->memento = NULL;
    return caretaker;
}

// 保存备忘录
void saveMemento(Caretaker *caretaker, Memento *memento) {
    caretaker->memento = memento;
}

// 获取备忘录
Memento* getMemento(const Caretaker *caretaker) {
    return caretaker->memento;
}

// 销毁管理者
void destroyCaretaker(Caretaker *caretaker) {
    if (caretaker->memento) destroyMemento(caretaker->memento);
    free(caretaker);
}

// 主函数
int main() {
    Originator *originator = createOriginator();
    Caretaker *caretaker = createCaretaker();

    setOriginatorText(originator, "Hello");
    printf("Current: %s\n", getOriginatorText(originator));

    Memento *memento = saveToMemento(originator);
    saveMemento(caretaker, memento);

    setOriginatorText(originator, "World");
    printf("Current: %s\n", getOriginatorText(originator));

    restoreFromMemento(originator, getMemento(caretaker));
    printf("Restored: %s\n", getOriginatorText(originator));

    destroyOriginator(originator);
    destroyCaretaker(caretaker);

    return 0;
}

3.2.代码解析

1. 初始化: 我们创建了一个 Originator 对象和一个 Caretaker 对象。
2. 设置初始状态: 我们通过调用 setOriginatorText() 将发起人的文本设置为 “Hello”。
3. 保存状态: 我们通过 saveToMemento() 创建了一个备忘录，并通过 saveMemento() 将其保存到管理者那里。
4. 改变状态: 发起人的文本被改为 “World”。
5. 恢复状态: 我们从管理者那里获取备忘录，并通过 restoreFromMemento() 恢复了发起人的状态回到 “Hello”。
6. 清理资源: 最后，我们释放了所有分配的内存。

3.3.代码运行

Current: Hello
Current: World
Restored: Hello