C++如何实现备忘录模式 C++备忘录模式的设计

备忘录模式是一种保存和恢复对象状态的设计模式，其核心在于通过备忘录类存储对象状态，发起人类负责创建和恢复状态，管理者类用于管理多个备忘录。1. 使用模板实现通用备忘录类，避免类型限制；2. 采用智能指针（如 std::shared_ptr）管理内存，防止内存泄漏；3. 注意深拷贝对象状态，确保备忘录数据独立；4. 在多线程环境下使用互斥锁（std::mutex）保证线程安全；5. 性能优化可通过增量式保存、共享状态、延迟复制或移动语义等方式实现。该模式广泛应用于撤销/重做功能、事务回滚、游戏存档和配置版本管理等场景。

备忘录模式，简单来说，就是把对象的状态保存下来，以后可以恢复到之前的状态。这在很多场景下都很有用，比如游戏存档、撤销操作等等。C++实现备忘录模式，核心在于定义一个备忘录类，用于存储对象的状态，以及一个发起人类，负责创建和恢复备忘录。

C++备忘录模式的设计

如何在C++中设计一个通用的备忘录类？

设计通用的备忘录类，要考虑到不同对象的状态可能差异很大。一种常见的做法是使用void*指针来存储状态，并配合一个类型标识符。但是，这种方式需要手动管理内存，容易出错。更安全的方式是使用模板，让备忘录类可以存储任意类型的数据。

立即学习“C++免费学习笔记（深入）”；

#include <iostream>
#include <memory>

template <typename T>
class Memento {
public:
    Memento(T state) : state_(std::make_shared<T>(state)) {}

    std::shared_ptr<T> getState() const {
        return state_;
    }

private:
    std::shared_ptr<T> state_;
};

template <typename T>
class Originator {
public:
    Originator(T state) : state_(state) {}

    void setState(T state) {
        state_ = state;
        std::cout << "State set to: " << state_ << std::endl;
    }

    Memento<T> saveStateToMemento() {
        std::cout << "Saving state to Memento: " << state_ << std::endl;
        return Memento<T>(state_);
    }

    void getStateFromMemento(Memento<T> memento) {
        state_ = *memento.getState();
        std::cout << "State after restoring from Memento: " << state_ << std::endl;
    }

private:
    T state_;
};

class Caretaker {
public:
    void add(Memento<int> state) {
        mementos_.push_back(state);
    }

    Memento<int> get(int index) const {
        return mementos_[index];
    }

private:
    std::vector<Memento<int>> mementos_;
};


int main() {
    Originator<int> originator(1);
    Caretaker caretaker;

    originator.setState(2);
    caretaker.add(originator.saveStateToMemento());

    originator.setState(3);
    caretaker.add(originator.saveStateToMemento());

    originator.setState(4);
    std::cout << "Current State: " << 4 << std::endl;

    originator.getStateFromMemento(caretaker.get(1));
    std::cout << "First saved State: " << originator.getStateFromMemento(caretaker.get(0)) << std::endl;

    return 0;
}

这段代码展示了如何使用模板来实现一个通用的备忘录模式。 Memento 类存储状态，Originator 类负责设置和恢复状态，Caretaker 类负责管理备忘录。 注意 std::shared_ptr 的使用，避免内存泄漏。

备忘录模式在实际项目中的应用场景有哪些？

备忘录模式在实际项目中有很多应用场景。

• 撤销/重做功能: 这是最常见的应用。编辑器、绘图软件等，都需要支持撤销和重做操作。每次操作前，保存对象的状态到备忘录，撤销时，从备忘录中恢复。
• 事务管理: 数据库事务需要保证原子性。如果事务失败，需要回滚到之前的状态。备忘录模式可以用来保存事务开始前的状态。
• 游戏存档: 游戏玩家可以随时保存游戏进度。备忘录模式可以用来保存游戏状态。
• 配置管理: 应用程序的配置可以有很多版本。备忘录模式可以用来保存不同版本的配置，方便切换。

如何优化C++备忘录模式的性能？

备忘录模式的性能瓶颈主要在于状态的复制。如果对象的状态很大，复制的开销会很大。可以考虑以下优化方法：

飞书多维表格

表格形态的AI工作流搭建工具，支持批量化的AI创作与分析任务，接入DeepSeek R1满血版

下载

• 增量式备忘录: 只保存状态的变化部分，而不是完整状态。
• 共享状态: 如果多个对象的状态相同，可以共享同一个备忘录。
• 延迟复制: 在真正需要恢复状态时，才进行复制。
• 使用移动语义: C++11引入了移动语义，可以避免不必要的复制。

例如，如果对象的状态是一个很大的数组，可以只保存数组中被修改的部分。

备忘录模式与其他设计模式的区别是什么？

备忘录模式容易与其他设计模式混淆，特别是与命令模式和状态模式。

• 备忘录模式 vs. 命令模式: 命令模式将请求封装成对象，可以用于记录和撤销操作。备忘录模式则是保存对象的状态，用于恢复。命令模式关注的是操作，备忘录模式关注的是状态。
• 备忘录模式 vs. 状态模式: 状态模式允许对象在内部状态改变时改变它的行为。备忘录模式则是保存对象的状态，用于外部恢复。状态模式关注的是对象内部的状态转换，备忘录模式关注的是对象外部的状态保存。

简单来说，命令模式是“做什么”，备忘录模式是“什么样”，状态模式是“我是谁”。

C++中实现备忘录模式有哪些常见的坑？

在C++中实现备忘录模式，容易遇到一些坑：

• 内存管理: 如果使用void*指针存储状态，需要手动管理内存，容易出现内存泄漏或野指针。使用智能指针可以避免这个问题。
• 深拷贝 vs. 浅拷贝: 备忘录需要保存对象的状态，必须进行深拷贝，而不是浅拷贝。否则，修改原始对象的状态，会影响备忘录中的状态。
• 线程安全: 如果多个线程同时访问备忘录，需要考虑线程安全问题。可以使用互斥锁来保护备忘录的状态。

例如，如果备忘录类只是简单地复制了对象的指针，而不是复制对象本身，那么修改原始对象的状态，备忘录中的状态也会被修改。这就是浅拷贝的问题。

如何在多线程环境下使用备忘录模式？

在多线程环境下使用备忘录模式，需要保证线程安全。一种常见的做法是使用互斥锁来保护备忘录的状态。

#include <iostream>
#include <mutex>
#include <thread>

// ... (省略前面的代码)

template <typename T>
class Originator {
public:
    Originator(T state) : state_(state) {}

    void setState(T state) {
        std::lock_guard<std::mutex> lock(mutex_);
        state_ = state;
        std::cout << "State set to: " << state_ << " by thread " << std::this_thread::get_id() << std::endl;
    }

    Memento<T> saveStateToMemento() {
        std::lock_guard<std::mutex> lock(mutex_);
        std::cout << "Saving state to Memento: " << state_ << " by thread " << std::this_thread::get_id() << std::endl;
        return Memento<T>(state_);
    }

    void getStateFromMemento(Memento<T> memento) {
        std::lock_guard<std::mutex> lock(mutex_);
        state_ = *memento.getState();
        std::cout << "State after restoring from Memento: " << state_ << " by thread " << std::this_thread::get_id() << std::endl;
    }

private:
    T state_;
    std::mutex mutex_;
};

// ... (省略后面的代码)

int main() {
    Originator<int> originator(1);
    Caretaker caretaker;

    std::thread t1([&]() {
        originator.setState(2);
        caretaker.add(originator.saveStateToMemento());
    });

    std::thread t2([&]() {
        originator.setState(3);
        caretaker.add(originator.saveStateToMemento());
    });

    t1.join();
    t2.join();

    originator.setState(4);
    std::cout << "Current State: " << 4 << std::endl;

    originator.getStateFromMemento(caretaker.get(0));

    return 0;
}

这段代码使用 std::mutex 来保护 Originator 类的状态。每个访问状态的方法都需要获取锁，以保证线程安全。 注意，过度使用锁会影响性能，需要根据实际情况进行权衡。