C++备忘录模式的实现方案与数据恢复机制详解-源码库

C++备忘录模式的实现方案与数据恢复机制详解

大家好，作为一名在C++领域摸爬滚打多年的开发者，今天我想和大家深入聊聊备忘录模式这个既实用又有趣的设计模式。记得有一次我在开发一个图形编辑器时，用户频繁要求撤销操作，当时如果早点想到备忘录模式，就能少走很多弯路了。备忘录模式的核心思想很简单——在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，以便以后可以将该对象恢复到原先保存的状态。

备忘录模式的基本概念

备忘录模式包含三个核心角色：Originator（发起人）、Memento（备忘录）和Caretaker（管理者）。Originator是需要保存状态的对象，Memento是存储Originator内部状态的对象，而Caretaker则负责保存和管理Memento对象。

在实际项目中，我特别喜欢使用备忘录模式来处理以下场景：文本编辑器的撤销/重做功能、游戏存档系统、配置管理器的状态回滚等。它的最大优势是将状态保存和恢复的逻辑与业务逻辑分离，让代码更加清晰可维护。

基础实现方案

让我们从一个简单的文本编辑器示例开始。假设我们要实现一个支持撤销操作的文本编辑器：


#include 
#include 
#include 
#include 

// 备忘录类
class TextMemento {
private:
    std::string content_;
    
public:
    TextMemento(const std::string& content) : content_(content) {}
    std::string getContent() const { return content_; }
};

// 发起人类 - 文本编辑器
class TextEditor {
private:
    std::string content_;
    
public:
    void write(const std::string& text) {
        content_ += text;
    }
    
    std::string getContent() const {
        return content_;
    }
    
    // 创建备忘录
    std::shared_ptr createMemento() {
        return std::make_shared(content_);
    }
    
    // 从备忘录恢复
    void restoreFromMemento(std::shared_ptr memento) {
        content_ = memento->getContent();
    }
};

// 管理者类
class HistoryManager {
private:
    std::vector> history_;
    
public:
    void saveState(std::shared_ptr memento) {
        history_.push_back(memento);
    }
    
    std::shared_ptr getLastState() {
        if (history_.empty()) return nullptr;
        auto lastState = history_.back();
        history_.pop_back();
        return lastState;
    }
};

这个基础版本虽然简单，但在实际使用中我发现了一个问题：如果频繁保存状态，内存占用会快速增长。后来我通过限制历史记录数量解决了这个问题。

高级实现与优化技巧

在实际项目中，我们往往需要处理更复杂的状态管理。下面是一个支持增量保存的优化版本：


#include 
#include 

class OptimizedTextEditor {
private:
    std::string content_;
    std::stack> undoStack_;
    std::stack> redoStack_;
    static const size_t MAX_HISTORY = 50; // 限制历史记录数量
    
public:
    void write(const std::string& text) {
        // 保存当前状态到撤销栈
        saveCurrentState();
        content_ += text;
        // 清空重做栈，因为新的操作使之前的重做记录无效
        clearRedoStack();
    }
    
    bool undo() {
        if (undoStack_.size() < 2) return false; // 需要至少两个状态才能撤销
        
        // 当前状态移到重做栈
        redoStack_.push(undoStack_.top());
        undoStack_.pop();
        
        // 恢复到上一个状态
        content_ = undoStack_.top()->getContent();
        return true;
    }
    
    bool redo() {
        if (redoStack_.empty()) return false;
        
        // 从重做栈恢复
        content_ = redoStack_.top()->getContent();
        undoStack_.push(redoStack_.top());
        redoStack_.pop();
        return true;
    }
    
private:
    void saveCurrentState() {
        if (undoStack_.size() >= MAX_HISTORY) {
            // 移除最旧的状态
            std::stack> temp;
            while (undoStack_.size() > 1) {
                temp.push(undoStack_.top());
                undoStack_.pop();
            }
            undoStack_.swap(temp);
        }
        undoStack_.push(std::make_shared(content_));
    }
    
    void clearRedoStack() {
        while (!redoStack_.empty()) {
            redoStack_.pop();
        }
    }
};

数据恢复机制详解

数据恢复是备忘录模式的核心价值所在。在我的实践中，总结了以下几种恢复策略：

1. 完整状态恢复：适用于状态数据量不大的场景，每次保存完整状态。


class CompleteStateRecovery {
private:
    std::string fullState_;
    
public:
    void setState(const std::string& state) {
        fullState_ = state;
    }
    
    std::string getState() const {
        return fullState_;
    }
};

2. 增量状态恢复：只保存发生变化的部分，适合大对象的状态管理。


class IncrementalStateRecovery {
private:
    struct StateDelta {
        size_t position;
        std::string oldValue;
        std::string newValue;
    };
    
    std::vector deltas_;
    std::string baseState_;
    
public:
    void applyDelta(size_t pos, const std::string& oldVal, const std::string& newVal) {
        deltas_.push_back({pos, oldVal, newVal});
    }
    
    std::string restoreToVersion(int version) {
        std::string result = baseState_;
        for (int i = 0; i <= version && i < deltas_.size(); ++i) {
            const auto& delta = deltas_[i];
            result.replace(delta.position, delta.oldValue.length(), delta.newValue);
        }
        return result;
    }
};

实战经验与踩坑提示

在多年的开发中，我积累了一些宝贵的经验教训：

1. 内存管理是关键：备忘录对象可能会占用大量内存，一定要实现合理的清理机制。我曾经在一个项目中因为忘记清理历史记录导致内存泄漏。

2. 深拷贝与浅拷贝：如果备忘录中包含指针成员，务必实现深拷贝，否则会出现悬垂指针的问题。


class DeepCopyMemento {
private:
    std::vector> data_;
    
public:
    // 深拷贝构造函数
    DeepCopyMemento(const DeepCopyMemento& other) {
        for (const auto& item : other.data_) {
            data_.push_back(std::make_unique(*item));
        }
    }
    
    DeepCopyMemento& operator=(const DeepCopyMemento& other) {
        if (this != &other) {
            data_.clear();
            for (const auto& item : other.data_) {
                data_.push_back(std::make_unique(*item));
            }
        }
        return *this;
    }
};

3. 性能优化：对于频繁状态保存的场景，可以考虑使用写时复制（Copy-on-Write）技术来优化性能。

4. 序列化支持：如果需要在程序重启后仍然能够恢复状态，记得为备忘录实现序列化功能。