命令模式解析与C++实战应用

1. 命令模式基础概念解析

命令模式是GoF 23种设计模式中行为型模式的一种，它将请求封装成对象，从而允许用户使用不同的请求、队列或日志来参数化其他对象。这种解耦方式在实际工程中非常实用，特别是在需要实现撤销/重做、事务处理等场景时。

我第一次在真实项目中应用命令模式是在开发一个图形编辑器时。当时需要实现一个支持多级撤销的操作历史记录功能，命令模式完美解决了这个问题。通过将每个编辑操作封装成命令对象，我们能够轻松实现操作序列的存储和回放。

命令模式的核心参与者包括：

• Invoker（调用者）：触发命令的对象
• Command（命令）：声明执行操作的接口
• ConcreteCommand（具体命令）：将接收者与动作绑定
• Receiver（接收者）：知道如何执行请求的具体对象
• Client（客户端）：创建具体命令并设置接收者

2. 命令模式的典型应用场景

2.1 GUI操作与撤销功能

在图形界面应用中，命令模式几乎是实现撤销/重做功能的标准方案。每个用户操作（如添加形状、修改属性）都被封装为一个命令对象，这些对象被存储在历史列表中。当用户触发撤销时，只需调用最近命令的undo()方法。

cpp复制// 示例：图形编辑器的移动命令
class MoveCommand : public Command {
public:
    MoveCommand(Shape* shape, const Point& delta)
        : shape(shape), delta(delta) {}
    
    void execute() override {
        shape->move(delta);
    }
    
    void undo() override {
        shape->move(Point(-delta.x, -delta.y));
    }

private:
    Shape* shape;
    Point delta;
};

2.2 任务队列与线程池

命令模式非常适合实现异步任务处理系统。我们可以将各种任务封装为命令对象，然后放入队列中由工作线程依次执行。这种设计在游戏开发中特别常见，比如将渲染命令、物理计算等不同任务统一封装。

cpp复制// 示例：线程池任务处理
class ThreadPool {
public:
    void addTask(std::unique_ptr<Command> task) {
        std::lock_guard<std::mutex> lock(queueMutex);
        taskQueue.push(std::move(task));
        condition.notify_one();
    }

    void workerThread() {
        while (running) {
            std::unique_ptr<Command> task;
            {
                std::unique_lock<std::mutex> lock(queueMutex);
                condition.wait(lock, [this]{ return !taskQueue.empty() || !running; });
                
                if (!running) break;
                
                task = std::move(taskQueue.front());
                taskQueue.pop();
            }
            task->execute();
        }
    }

private:
    std::queue<std::unique_ptr<Command>> taskQueue;
    std::mutex queueMutex;
    std::condition_variable condition;
    bool running = true;
};

2.3 游戏开发中的输入处理

在游戏引擎中，命令模式常被用来处理玩家输入。不同的按键可以绑定到不同的命令对象，使得按键配置可以在运行时灵活改变。这种设计也便于实现"回放"功能，只需记录执行过的命令序列。

cpp复制// 示例：游戏输入处理
class InputHandler {
public:
    void handleInput() {
        if (isPressed(BUTTON_X)) buttonX->execute();
        if (isPressed(BUTTON_Y)) buttonY->execute();
        // ...
    }
    
    void bindCommand(Button button, std::unique_ptr<Command> command) {
        switch (button) {
            case BUTTON_X: buttonX = std::move(command); break;
            case BUTTON_Y: buttonY = std::move(command); break;
            // ...
        }
    }

private:
    std::unique_ptr<Command> buttonX;
    std::unique_ptr<Command> buttonY;
    // ...
};

3. C++实现命令模式的最佳实践

3.1 接口设计与内存管理

在C++中实现命令模式时，接口设计需要考虑资源管理和性能问题。我推荐使用智能指针来管理命令对象的生命周期，特别是在需要长期保存命令对象（如实现撤销栈）的场景中。

cpp复制class Command {
public:
    virtual ~Command() = default;
    virtual void execute() = 0;
    virtual void undo() = 0;
    virtual bool isReversible() const { return true; }
};

// 使用示例
std::vector<std::unique_ptr<Command>> commandHistory;

void executeCommand(std::unique_ptr<Command> cmd) {
    cmd->execute();
    if (cmd->isReversible()) {
        commandHistory.push_back(std::move(cmd));
    }
}

3.2 性能优化技巧

命令对象可能被频繁创建和销毁，特别是在游戏循环等性能敏感场景中。这时可以考虑使用对象池模式来重用命令对象，减少内存分配开销。

cpp复制class CommandPool {
public:
    template<typename T, typename... Args>
    std::unique_ptr<T, std::function<void(T*)>> acquire(Args&&... args) {
        if (pool.empty()) {
            return std::unique_ptr<T, std::function<void(T*)>>(
                new T(std::forward<Args>(args)...),
                [this](T* p) { pool.push_back(std::unique_ptr<T>(p)); });
        }
        
        auto ptr = std::move(pool.back());
        pool.pop_back();
        *ptr = T(std::forward<Args>(args)...);
        return std::unique_ptr<T, std::function<void(T*)>>(
            ptr.release(),
            [this](T* p) { pool.push_back(std::unique_ptr<T>(p)); });
    }

private:
    std::vector<std::unique_ptr<Command>> pool;
};

3.3 现代C++特性应用

C++11及以后版本提供的lambda表达式可以简化命令模式的实现，特别是在只需要简单操作的场景中，可以避免创建单独的Command子类。

cpp复制// 使用lambda创建临时命令
auto cmd = make_command(
    [=]() { target->doSomething(params); },  // execute
    [=]() { target->undoSomething(params); } // undo
);

// make_command实现示例
template<typename Execute, typename Undo>
auto make_command(Execute&& execute, Undo&& undo) {
    class LambdaCommand : public Command {
    public:
        LambdaCommand(Execute&& e, Undo&& u)
            : execute(std::forward<Execute>(e))
            , undo(std::forward<Undo>(u)) {}
        
        void execute() override { execute(); }
        void undo() override { undo(); }

    private:
        Execute execute;
        Undo undo;
    };
    
    return std::make_unique<LambdaCommand>(
        std::forward<Execute>(execute),
        std::forward<Undo>(undo));
}

4. 命令模式的高级应用与变体

4.1 组合命令（宏命令）

组合命令允许将多个命令组合成一个复合命令，这在实现复杂操作或批量操作时非常有用。我在一个CAD软件项目中就使用这种技术来实现"组合操作"功能。

cpp复制class MacroCommand : public Command {
public:
    void addCommand(std::unique_ptr<Command> cmd) {
        commands.push_back(std::move(cmd));
    }
    
    void execute() override {
        for (auto it = commands.begin(); it != commands.end(); ++it) {
            (*it)->execute();
        }
    }
    
    void undo() override {
        for (auto it = commands.rbegin(); it != commands.rend(); ++it) {
            (*it)->undo();
        }
    }

private:
    std::vector<std::unique_ptr<Command>> commands;
};

4.2 事务处理系统

命令模式可以扩展实现简单的事务处理系统。每个命令除了执行和撤销方法外，还可以加入验证逻辑，只有所有命令都验证通过才会执行。

cpp复制class Transaction {
public:
    void addCommand(std::unique_ptr<Command> cmd) {
        commands.push_back(std::move(cmd));
    }
    
    bool execute() {
        // 验证阶段
        for (const auto& cmd : commands) {
            if (!cmd->validate()) {
                return false;
            }
        }
        
        // 执行阶段
        executedCommands.clear();
        for (auto& cmd : commands) {
            cmd->execute();
            executedCommands.push_back(std::move(cmd));
        }
        
        commands.clear();
        return true;
    }
    
    void rollback() {
        for (auto it = executedCommands.rbegin(); it != executedCommands.rend(); ++it) {
            (*it)->undo();
        }
    }

private:
    std::vector<std::unique_ptr<Command>> commands;
    std::vector<std::unique_ptr<Command>> executedCommands;
};

4.3 命令模式的扩展应用

在分布式系统中，命令模式可以扩展为"命令消息"，将命令序列化后通过网络传输，在远程节点上执行。我在一个物联网项目中就使用这种技术来实现远程设备控制。

cpp复制class RemoteCommand : public Command {
public:
    virtual std::string serialize() const = 0;
    static std::unique_ptr<RemoteCommand> deserialize(const std::string& data);
};

class LightOnCommand : public RemoteCommand {
public:
    LightOnCommand(int deviceId) : deviceId(deviceId) {}
    
    void execute() override {
        // 实际项目中这里会是网络通信代码
        std::cout << "Turning on light " << deviceId << std::endl;
    }
    
    std::string serialize() const override {
        return "light:on:" + std::to_string(deviceId);
    }
    
    static std::unique_ptr<LightOnCommand> deserialize(const std::string& data) {
        // 解析data字符串...
        return std::make_unique<LightOnCommand>(parsedDeviceId);
    }

private:
    int deviceId;
};

5. 命令模式的优缺点与替代方案

5.1 命令模式的优势

• 解耦调用者与执行者：调用者不需要知道具体的执行细节
• 支持撤销/重做：通过维护命令历史轻松实现
• 支持事务：可以构建原子操作序列
• 灵活性：可以轻松组合、排队、记录命令
• 可扩展性：新命令可以随时添加而不影响现有代码

5.2 命令模式的局限性

• 性能开销：每个操作都需要创建命令对象
• 内存占用：实现撤销功能需要保存所有命令对象
• 复杂性增加：简单操作也需要创建多个类
• 可能导致过度设计：不是所有场景都需要这种灵活性

5.3 替代方案比较

在实际项目中，我通常会根据以下标准决定是否使用命令模式：

1. 是否需要撤销/重做功能
2. 操作是否需要排队或记录
3. 调用者与执行者是否需要完全解耦
4. 操作是否足够复杂，值得引入额外抽象层

6. 实战案例：文本编辑器的命令模式实现

让我们通过一个完整的文本编辑器示例来展示命令模式的实战应用。这个编辑器将支持基本的文本编辑操作，并实现撤销/重做功能。

6.1 基础架构设计

cpp复制// 接收者 - 文档类
class Document {
public:
    void insert(size_t pos, const std::string& text) {
        content.insert(pos, text);
    }
    
    void erase(size_t pos, size_t len) {
        content.erase(pos, len);
    }
    
    const std::string& getContent() const { return content; }

private:
    std::string content;
};

// 命令基类
class EditorCommand {
public:
    virtual ~EditorCommand() = default;
    virtual void execute() = 0;
    virtual void undo() = 0;
    virtual std::string getDescription() const = 0;
};

// 具体命令 - 插入文本
class InsertCommand : public EditorCommand {
public:
    InsertCommand(Document& doc, size_t pos, const std::string& text)
        : doc(doc), pos(pos), text(text) {}
    
    void execute() override { doc.insert(pos, text); }
    
    void undo() override { doc.erase(pos, text.length()); }
    
    std::string getDescription() const override {
        return "Insert \"" + text + "\" at position " + std::to_string(pos);
    }

private:
    Document& doc;
    size_t pos;
    std::string text;
};

// 具体命令 - 删除文本
class EraseCommand : public EditorCommand {
public:
    EraseCommand(Document& doc, size_t pos, size_t len)
        : doc(doc), pos(pos), len(len), deletedText(doc.getContent().substr(pos, len)) {}
    
    void execute() override { doc.erase(pos, len); }
    
    void undo() override { doc.insert(pos, deletedText); }
    
    std::string getDescription() const override {
        return "Erase " + std::to_string(len) + " chars at position " + std::to_string(pos);
    }

private:
    Document& doc;
    size_t pos;
    size_t len;
    std::string deletedText;
};

6.2 撤销系统实现

cpp复制class Editor {
public:
    void executeCommand(std::unique_ptr<EditorCommand> cmd) {
        cmd->execute();
        undoStack.push(std::move(cmd));
        redoStack = std::stack<std::unique_ptr<EditorCommand>>(); // 清空重做栈
    }
    
    bool undo() {
        if (undoStack.empty()) return false;
        
        auto cmd = std::move(undoStack.top());
        undoStack.pop();
        cmd->undo();
        redoStack.push(std::move(cmd));
        return true;
    }
    
    bool redo() {
        if (redoStack.empty()) return false;
        
        auto cmd = std::move(redoStack.top());
        redoStack.pop();
        cmd->execute();
        undoStack.push(std::move(cmd));
        return true;
    }
    
    void printHistory() const {
        std::cout << "Undo stack:\n";
        printStack(undoStack);
        std::cout << "\nRedo stack:\n";
        printStack(redoStack);
    }

private:
    Document doc;
    std::stack<std::unique_ptr<EditorCommand>> undoStack;
    std::stack<std::unique_ptr<EditorCommand>> redoStack;
    
    static void printStack(const std::stack<std::unique_ptr<EditorCommand>>& stack) {
        auto temp = stack;
        std::vector<std::string> items;
        while (!temp.empty()) {
            items.push_back(temp.top()->getDescription());
            temp.pop();
        }
        for (auto it = items.rbegin(); it != items.rend(); ++it) {
            std::cout << " - " << *it << "\n";
        }
    }
};

6.3 使用示例

cpp复制int main() {
    Editor editor;
    
    // 执行一系列编辑操作
    editor.executeCommand(std::make_unique<InsertCommand>(editor.getDocument(), 0, "Hello"));
    editor.executeCommand(std::make_unique<InsertCommand>(editor.getDocument(), 5, " World"));
    editor.executeCommand(std::make_unique<EraseCommand>(editor.getDocument(), 5, 1));
    
    std::cout << "Current document: " << editor.getDocument().getContent() << "\n\n";
    
    // 查看操作历史
    editor.printHistory();
    
    // 执行撤销
    editor.undo();
    std::cout << "\nAfter undo: " << editor.getDocument().getContent() << "\n";
    
    // 执行重做
    editor.redo();
    std::cout << "After redo: " << editor.getDocument().getContent() << "\n";
    
    return 0;
}

这个案例展示了命令模式在实现编辑器撤销系统时的典型应用。通过将每个编辑操作封装为命令对象，我们可以轻松实现多级撤销/重做功能，同时保持代码的清晰和可维护性。

7. 性能考量与优化策略

在实际项目中应用命令模式时，性能是需要特别关注的问题。以下是我在多年实践中总结的一些优化经验：

7.1 对象创建优化

命令对象的频繁创建和销毁可能导致性能瓶颈。对于性能敏感的场景，可以考虑以下优化：

1. 对象池技术：预先分配一批命令对象，循环使用
2. 轻量级命令：将大对象存储在外部，命令只保存引用
3. 命令合并：将多个连续小操作合并为一个复合命令

cpp复制// 对象池实现示例
class CommandPool {
public:
    template<typename T, typename... Args>
    std::unique_ptr<T, std::function<void(T*)>> create(Args&&... args) {
        if (freeList.empty()) {
            return std::unique_ptr<T, std::function<void(T*)>>(
                new T(std::forward<Args>(args)...),
                [this](T* p) { freeList.push_back(p); });
        }
        
        T* ptr = freeList.back();
        freeList.pop_back();
        *ptr = T(std::forward<Args>(args)...);
        return std::unique_ptr<T, std::function<void(T*)>>(
            ptr,
            [this](T* p) { freeList.push_back(p); });
    }

private:
    std::vector<Command*> freeList;
};

7.2 内存管理策略

长期维护命令历史（如实现无限撤销）可能导致内存占用过高。可以考虑：

1. 限制历史深度：只保留最近的N个命令
2. 检查点机制：定期保存完整状态，只记录后续增量命令
3. 懒加载：将不常用的命令序列化到磁盘

cpp复制// 有限历史实现
class LimitedHistory {
public:
    void push(std::unique_ptr<Command> cmd) {
        if (history.size() >= maxSize) {
            history.pop_front();
        }
        history.push_back(std::move(cmd));
    }
    
    std::unique_ptr<Command> pop() {
        if (history.empty()) return nullptr;
        auto cmd = std::move(history.back());
        history.pop_back();
        return cmd;
    }

private:
    std::deque<std::unique_ptr<Command>> history;
    size_t maxSize = 100; // 最多保存100个命令
};

7.3 多线程环境下的命令模式

在多线程应用中使用命令模式需要特别注意线程安全问题：

1. 命令不可变性：执行后命令状态不应改变
2. 线程安全队列：使用锁或原子操作保护命令队列
3. 执行隔离：确保命令执行不影响共享状态

cpp复制// 线程安全命令队列
class ConcurrentCommandQueue {
public:
    void push(std::unique_ptr<Command> cmd) {
        std::lock_guard<std::mutex> lock(mutex);
        queue.push(std::move(cmd));
        cv.notify_one();
    }
    
    std::unique_ptr<Command> pop() {
        std::unique_lock<std::mutex> lock(mutex);
        cv.wait(lock, [this] { return !queue.empty(); });
        auto cmd = std::move(queue.front());
        queue.pop();
        return cmd;
    }

private:
    std::queue<std::unique_ptr<Command>> queue;
    std::mutex mutex;
    std::condition_variable cv;
};

在实际项目中，我通常会根据具体场景混合使用这些优化策略。例如，在一个图形编辑器中，我们可能同时使用对象池来管理绘图命令，限制撤销历史深度，并使用线程安全队列来处理后台渲染命令。