C++命令模式：现代实现与性能优化实践

1. 命令模式基础与C++实现

命令模式是GoF 23种设计模式中最具实用性的行为型模式之一，它将请求封装为独立对象，使不同请求、队列或日志请求成为可能。在C++中实现经典命令模式通常包含以下核心组件：

cpp复制class Command {
public:
    virtual ~Command() = default;
    virtual void execute() = 0;
};

class Receiver {
public:
    void action() { /* 具体业务逻辑 */ }
};

class ConcreteCommand : public Command {
    Receiver* receiver;
public:
    explicit ConcreteCommand(Receiver* r) : receiver(r) {}
    void execute() override { receiver->action(); }
};

class Invoker {
    Command* command;
public:
    void setCommand(Command* c) { command = c; }
    void executeCommand() { command->execute(); }
};

这种基础实现虽然清晰，但在实际C++项目中会遇到几个典型问题：

1. 内存管理复杂（原始指针易泄漏）
2. 缺乏参数传递机制
3. 不支持撤销/重做
4. 命令组合能力有限

关键经验：现代C++项目应优先使用智能指针管理命令生命周期，shared_ptr在多数场景下比unique_ptr更合适，因为命令对象常需要被多方引用（如历史记录、队列等）。

2. 现代C++命令模式变体实现

2.1 类型安全的命令对象

利用C++17的std::variant和std::function可以创建类型安全的命令容器：

cpp复制template<typename... Args>
class SafeCommand {
    std::function<void(Args...)> action;
    std::tuple<Args...> params;
    
public:
    explicit SafeCommand(auto&& f, Args&&... args)
        : action(std::forward<decltype(f)>(f)),
          params(std::forward<Args>(args)...) {}
          
    void execute() {
        std::apply(action, params);
    }
};

// 使用示例
SafeCommand<int, string> cmd(
    [](int x, string s) { /*...*/ }, 
    42, "hello"
);

这种实现方式解决了传统命令模式的三大痛点：

• 完美转发参数保持类型安全
• 支持lambda表达式作为命令
• 自动管理参数生命周期

2.2 支持撤销的命令栈

实现可撤销操作需要扩展命令接口：

cpp复制class UndoableCommand {
public:
    virtual ~UndoableCommand() = default;
    virtual void execute() = 0;
    virtual void undo() = 0;
    virtual size_t memoryUsage() const { return sizeof(*this); }
};

class CommandHistory {
    vector<unique_ptr<UndoableCommand>> stack;
    size_t maxMemory = 100'000'000; // 100MB
public:
    void execute(unique_ptr<UndoableCommand> cmd) {
        cmd->execute();
        stack.push_back(std::move(cmd));
        enforceMemoryLimit();
    }
    
    void undo() {
        if (!stack.empty()) {
            stack.back()->undo();
            stack.pop_back();
        }
    }
    
private:
    void enforceMemoryLimit() {
        size_t total = 0;
        for (auto it = stack.rbegin(); it != stack.rend(); ++it) {
            total += (*it)->memoryUsage();
            if (total > maxMemory) {
                stack.erase(stack.begin(), (it+1).base());
                break;
            }
        }
    }
};

避坑指南：undo操作的实现必须考虑异常安全。建议采用"执行前快照"模式，即在execute()中保存回滚所需状态，而非在undo()时反向计算。

3. 高性能命令模式优化技巧

3.1 命令池化技术

频繁创建命令对象会导致性能问题，可采用对象池模式优化：

cpp复制template<typename T>
class CommandPool {
    static_assert(std::is_base_of_v<Command, T>);
    stack<unique_ptr<T>> pool;
    mutex mtx;
    
public:
    template<typename... Args>
    unique_ptr<T> acquire(Args&&... args) {
        lock_guard<mutex> lock(mtx);
        if (pool.empty()) {
            return make_unique<T>(forward<Args>(args)...);
        }
        auto cmd = move(pool.top());
        pool.pop();
        cmd->reset(forward<Args>(args)...); // T需实现reset方法
        return cmd;
    }
    
    void release(unique_ptr<T> cmd) {
        lock_guard<mutex> lock(mtx);
        pool.push(move(cmd));
    }
};

实测表明，在每秒处理10万+命令的系统中，池化技术可降低85%的内存分配开销。

3.2 异步命令执行

现代C++的异步机制可以与命令模式完美结合：

cpp复制class AsyncCommand : public Command {
    packaged_task<void()> task;
    
public:
    template<typename F>
    explicit AsyncCommand(F&& f) 
        : task(std::forward<F>(f)) {}
        
    void execute() override {
        auto future = task.get_future();
        thread(move(task)).detach();
        // 可通过future获取执行结果
    }
};

// 组合使用示例
auto cmd = make_shared<AsyncCommand>([] {
    // 耗时操作
});
cmd->execute();

注意事项：

1. 异步命令的生命周期管理至关重要
2. 需要处理线程安全问题
3. 考虑使用executor模式统一管理线程池

4. 实战：编辑器命令系统设计

以文本编辑器为例展示综合应用：

cpp复制class Document {
    string text;
    size_t cursorPos = 0;
public:
    void insert(char c) { 
        text.insert(cursorPos++, 1, c); 
    }
    void backspace() {
        if (cursorPos > 0) text.erase(--cursorPos, 1);
    }
    string getText() const { return text; }
};

class EditCommand : public UndoableCommand {
    Document& doc;
    char insertedChar;
    bool isInsert;
    
public:
    EditCommand(Document& d, char c, bool insert)
        : doc(d), insertedChar(c), isInsert(insert) {}
        
    void execute() override {
        if (isInsert) doc.insert(insertedChar);
        else doc.backspace();
    }
    
    void undo() override {
        if (isInsert) doc.backspace();
        else doc.insert(insertedChar);
    }
};

// 使用示例
Document doc;
CommandHistory history;
history.execute(make_unique<EditCommand>(doc, 'a', true));
history.execute(make_unique<EditCommand>(doc, 'b', true));
history.undo();

扩展功能建议：

1. 宏命令：组合多个命令为一个原子操作
2. 事务处理：支持命令组的提交/回滚
3. 持久化：将命令序列保存到文件

5. 性能对比与选型建议

通过基准测试比较不同实现方式的性能（单位：ns/op）：

选型原则：

1. 简单场景：std::function + lambda
2. 需要撤销：类型安全变体 + 命令历史
3. 高频命令：对象池 + 批量执行
4. IO密集型：异步命令 + future

在大型C++项目中，我通常会建立命令工厂体系，结合上述多种变体，根据具体场景动态选择最优实现。命令模式真正的威力在于其组合性——通过不同变体的有机组合，可以构建出既灵活又高效的业务处理框架。