C++命令模式的实战应用与系统架构设计指南-源码库

C++命令模式的实战应用与系统架构设计指南

作为一名在C++领域摸爬滚打多年的开发者，我深刻体会到设计模式在构建复杂系统时的重要性。今天我想和大家深入探讨命令模式（Command Pattern）在C++项目中的实战应用，以及如何将其融入系统架构设计中。记得我第一次在大型项目中应用命令模式时，那种”原来如此”的顿悟感至今难忘。

什么是命令模式？为什么需要它？

命令模式的核心思想是将请求封装成对象，从而允许你参数化客户端与不同的请求、队列或日志请求，以及支持可撤销的操作。简单来说，就是把”做什么”和”谁来做”解耦。

在我参与的一个图形编辑器项目中，最初的设计是这样的：每个菜单项直接调用具体的操作函数。随着功能增加，代码变得越来越臃肿，撤销/重做功能实现起来异常困难。直到我们重构为命令模式，问题才迎刃而解。

基础实现：构建命令模式框架

让我们从最基础的命令接口开始：


// 命令接口
class Command {
public:
    virtual ~Command() = default;
    virtual void execute() = 0;
    virtual void undo() = 0;
};

接下来实现具体的命令类。假设我们有一个文档编辑器：


class InsertTextCommand : public Command {
private:
    Document& document_;
    std::string text_;
    size_t position_;
    std::string previousContent_;
    
public:
    InsertTextCommand(Document& doc, const std::string& text, size_t pos)
        : document_(doc), text_(text), position_(pos) {}
    
    void execute() override {
        previousContent_ = document_.getContent();
        document_.insertText(position_, text_);
    }
    
    void undo() override {
        document_.setContent(previousContent_);
    }
};

这里有个实战经验：在execute()中保存状态，而不是在构造函数中。这样可以避免命令对象创建时的不必要开销。

命令管理器：实现撤销/重做功能

命令模式最强大的特性之一就是支持操作的撤销和重做。下面是命令管理器的实现：


class CommandManager {
private:
    std::vector> undoStack_;
    std::vector> redoStack_;
    const size_t maxHistorySize_ = 100;
    
public:
    void executeCommand(std::unique_ptr command) {
        command->execute();
        undoStack_.push_back(std::move(command));
        
        // 清理重做栈
        redoStack_.clear();
        
        // 限制历史记录大小
        if (undoStack_.size() > maxHistorySize_) {
            undoStack_.erase(undoStack_.begin());
        }
    }
    
    void undo() {
        if (undoStack_.empty()) return;
        
        auto command = std::move(undoStack_.back());
        undoStack_.pop_back();
        command->undo();
        redoStack_.push_back(std::move(command));
    }
    
    void redo() {
        if (redoStack_.empty()) return;
        
        auto command = std::move(redoStack_.back());
        redoStack_.pop_back();
        command->execute();
        undoStack_.push_back(std::move(command));
    }
};

踩坑提示：记得要限制历史记录的大小，否则长时间使用会导致内存泄漏。我在实际项目中就遇到过因为忘记限制栈大小而导致的内存问题。

高级应用：宏命令和命令组合

命令模式真正展现威力是在需要组合多个命令时。比如实现”格式刷”功能：


class MacroCommand : public Command {
private:
    std::vector> commands_;
    
public:
    void addCommand(std::unique_ptr command) {
        commands_.push_back(std::move(command));
    }
    
    void execute() override {
        for (auto& command : commands_) {
            command->execute();
        }
    }
    
    void undo() override {
        for (auto it = commands_.rbegin(); it != commands_.rend(); ++it) {
            (*it)->undo();
        }
    }
};

使用示例：


auto macro = std::make_unique();
macro->addCommand(std::make_unique(document, "Arial"));
macro->addCommand(std::make_unique(document, Color::Blue));
macro->addCommand(std::make_unique(document, 12));

commandManager.executeCommand(std::move(macro));

系统架构设计中的命令模式

在大型系统架构中，命令模式可以发挥更大的作用。我在设计一个分布式任务调度系统时，就大量使用了命令模式：


// 网络命令基类
class NetworkCommand : public Command {
protected:
    std::string targetNode_;
    ConnectionManager& connectionMgr_;
    
public:
    NetworkCommand(const std::string& target, ConnectionManager& mgr)
        : targetNode_(target), connectionMgr_(mgr) {}
    
    virtual std::string serialize() const = 0;
    virtual void deserialize(const std::string& data) = 0;
};

class DataSyncCommand : public NetworkCommand {
private:
    std::vector records_;
    
public:
    using NetworkCommand::NetworkCommand;
    
    void execute() override {
        auto connection = connectionMgr_.getConnection(targetNode_);
        connection->send(serialize());
    }
    
    std::string serialize() const override {
        // 序列化实现
        return "sync_data:" + std::to_string(records_.size());
    }
    
    void deserialize(const std::string& data) override {
        // 反序列化实现
    }
    
    void undo() override {
        // 实现数据回滚
        auto rollbackCmd = std::make_unique(
            targetNode_, connectionMgr_, records_);
        commandManager.executeCommand(std::move(rollbackCmd));
    }
};

性能优化和最佳实践

在实际项目中，我总结了一些命令模式的优化技巧：

1. 使用对象池：对于频繁创建的命令对象，使用对象池可以显著减少内存分配开销。


class CommandPool {
private:
    std::unordered_map>> pool_;
    
public:
    template
    std::unique_ptr acquire(Args&&... args) {
        auto& pool = pool_[typeid(T)];
        if (!pool.empty()) {
            auto cmd = std::move(pool.back());
            pool.pop_back();
            return std::unique_ptr(static_cast(cmd.release()));
        }
        return std::make_unique(std::forward(args)...);
    }
    
    template
    void release(std::unique_ptr command) {
        pool_[typeid(T)].push_back(std::move(command));
    }
};

2. 延迟执行：对于耗时操作，可以实现异步命令：


class AsyncCommand : public Command {
private:
    std::future future_;
    std::atomic executed_{false};
    
public:
    void execute() override {
        if (!executed_) {
            future_ = std::async(std::launch::async, [this]() {
                this->doExecute();
            });
            executed_ = true;
        }
    }
    
    virtual void doExecute() = 0;
};

测试策略

命令模式的测试相对直观，我通常采用以下策略：


TEST(CommandPatternTest, UndoRedoWorkflow) {
    Document doc;
    CommandManager manager;
    
    auto initialContent = doc.getContent();
    
    // 执行命令
    manager.executeCommand(
        std::make_unique(doc, "Hello", 0));
    EXPECT_EQ(doc.getContent(), "Hello");
    
    // 撤销
    manager.undo();
    EXPECT_EQ(doc.getContent(), initialContent);
    
    // 重做
    manager.redo();
    EXPECT_EQ(doc.getContent(), "Hello");
}