C++命令模式实战：游戏开发中的解耦与撤销实现

1. 命令模式的核心价值与应用场景

在C++开发中，命令模式（Command Pattern）是一种行为型设计模式，它将请求封装为独立的对象，使你可以参数化客户端对象。这种解耦带来的直接好处是，调用者无需知道具体实现细节，只需通过命令对象来触发操作。

我曾在游戏开发中深刻体会到命令模式的威力。当时需要实现一个支持撤销/重做的关卡编辑器，命令模式完美解决了操作历史记录问题。每个编辑动作都被封装成命令对象，存储在堆栈中，撤销时只需执行反向操作即可。

命令模式特别适合以下场景：

• 需要实现操作回滚（Undo/Redo）功能
• 需要将操作排队、记录或延迟执行
• 需要支持宏命令（组合多个命令）
• 需要实现回调机制

2. 命令模式的经典实现结构

2.1 UML类图解析

标准的命令模式包含以下几个关键角色：

• Command：声明执行操作的接口
• ConcreteCommand：将接收者绑定到动作
• Invoker：要求命令执行请求
• Receiver：知道如何执行操作

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

// 具体命令
class ConcreteCommand : public Command {
    Receiver* receiver_;
    // 命令参数
public:
    ConcreteCommand(Receiver* receiver) : receiver_(receiver) {}
    
    void execute() override {
        receiver_->action();
    }
    
    void undo() override {
        receiver_->reverseAction();
    }
};

// 调用者
class Invoker {
    Command* command_;
public:
    void setCommand(Command* command) {
        command_ = command;
    }
    
    void executeCommand() {
        command_->execute();
    }
};

// 接收者
class Receiver {
public:
    void action() {
        // 实际业务逻辑
    }
    
    void reverseAction() {
        // 撤销逻辑
    }
};

2.2 实际开发中的变体

在实际项目中，我经常使用这些优化变体：

1. 智能指针管理：用std::unique_ptr管理命令对象生命周期
2. 模板命令：使用模板避免为每个命令创建子类
3. 组合命令：实现宏命令模式，批量执行多个命令

cpp复制// 模板命令示例
template <typename Receiver>
class TemplateCommand : public Command {
    using Action = void (Receiver::*)();
    
    Receiver* receiver_;
    Action action_;
public:
    TemplateCommand(Receiver* r, Action a) 
        : receiver_(r), action_(a) {}
        
    void execute() override {
        (receiver_->*action_)();
    }
};

3. 游戏开发中的实战案例

3.1 实现游戏角色移动系统

假设我们要开发一个RPG游戏，角色移动系统非常适合使用命令模式：

cpp复制class Character {
public:
    void moveTo(int x, int y) {
        // 实际移动逻辑
    }
    
    void undoMove(int x, int y) {
        // 撤销移动
    }
};

class MoveCommand : public Command {
    Character* character_;
    int fromX_, fromY_;
    int toX_, toY_;
public:
    MoveCommand(Character* c, int toX, int toY)
        : character_(c), toX_(toX), toY_(toY) {}
        
    void execute() override {
        fromX_ = character_->getX();
        fromY_ = character_->getY();
        character_->moveTo(toX_, toY_);
    }
    
    void undo() override {
        character_->moveTo(fromX_, fromY_);
    }
};

3.2 实现命令队列

游戏中的AI系统常常需要将命令排队执行：

cpp复制class CommandQueue {
    std::queue<std::unique_ptr<Command>> queue_;
public:
    void addCommand(std::unique_ptr<Command> cmd) {
        queue_.push(std::move(cmd));
    }
    
    void executeAll() {
        while (!queue_.empty()) {
            auto cmd = std::move(queue_.front());
            queue_.pop();
            cmd->execute();
        }
    }
};

4. 高级应用技巧与性能优化

4.1 命令池模式

频繁创建/销毁命令对象会影响性能，可以使用对象池技术：

cpp复制class CommandPool {
    std::vector<std::unique_ptr<Command>> pool_;
public:
    template <typename T, typename... Args>
    T* acquire(Args&&... args) {
        auto cmd = std::make_unique<T>(std::forward<Args>(args)...);
        T* ptr = cmd.get();
        pool_.push_back(std::move(cmd));
        return ptr;
    }
    
    void clear() {
        pool_.clear();
    }
};

4.2 异步命令执行

对于耗时操作，可以实现异步命令：

cpp复制class AsyncCommand : public Command {
    std::future<void> future_;
    std::function<void()> task_;
public:
    AsyncCommand(std::function<void()> task) : task_(task) {}
    
    void execute() override {
        future_ = std::async(std::launch::async, task_);
    }
    
    void wait() {
        if (future_.valid()) {
            future_.wait();
        }
    }
};

5. 常见问题与调试技巧

5.1 内存管理陷阱

命令模式常见的内存问题包括：

• 命令对象生命周期管理不当
• 接收者被提前释放
• 命令队列中的悬空指针

解决方案：

• 使用智能指针管理对象生命周期
• 采用弱引用或shared/weak_ptr处理接收者
• 实现命令的深拷贝

5.2 多线程注意事项

在多线程环境下使用命令模式时：

• 确保命令对象是线程安全的
• 使用原子操作或互斥锁保护共享状态
• 考虑使用命令队列+工作线程模式

cpp复制class ThreadSafeCommandQueue {
    std::queue<std::unique_ptr<Command>> queue_;
    std::mutex mutex_;
public:
    void addCommand(std::unique_ptr<Command> cmd) {
        std::lock_guard<std::mutex> lock(mutex_);
        queue_.push(std::move(cmd));
    }
    
    void executeAll() {
        std::unique_lock<std::mutex> lock(mutex_);
        auto tempQueue = std::move(queue_);
        lock.unlock();
        
        while (!tempQueue.empty()) {
            auto cmd = std::move(tempQueue.front());
            tempQueue.pop();
            cmd->execute();
        }
    }
};

5.3 性能优化技巧

1. 命令合并：将多个小命令合并为一个大命令
2. 轻量命令：对于简单操作，使用函数指针或lambda
3. 预分配内存：使用内存池减少动态分配开销

cpp复制// 使用lambda的轻量命令示例
class LambdaCommand : public Command {
    std::function<void()> execute_;
    std::function<void()> undo_;
public:
    LambdaCommand(std::function<void()> exec, 
                 std::function<void()> undo = {})
        : execute_(exec), undo_(undo) {}
        
    void execute() override { if (execute_) execute_(); }
    void undo() override { if (undo_) undo_(); }
};

6. 现代C++中的优雅实现

6.1 使用std::function

C++11以后，可以用std::function简化命令接口：

cpp复制class ModernCommand {
    std::function<void()> execute_;
    std::function<void()> undo_;
public:
    template <typename Exec, typename Undo>
    ModernCommand(Exec&& exec, Undo&& undo)
        : execute_(std::forward<Exec>(exec))
        , undo_(std::forward<Undo>(undo)) {}
        
    void execute() { execute_(); }
    void undo() { undo_(); }
};

6.2 可变参数模板命令

支持任意参数的命令实现：

cpp复制template <typename... Args>
class VariadicCommand {
    std::function<void(Args...)> execute_;
    std::function<void(Args...)> undo_;
public:
    VariadicCommand(std::function<void(Args...)> exec,
                   std::function<void(Args...)> undo = {})
        : execute_(exec), undo_(undo) {}
        
    void operator()(Args... args) {
        execute_(args...);
    }
    
    void undo(Args... args) {
        if (undo_) undo_(args...);
    }
};

6.3 结合Lambda表达式

现代C++最简洁的命令模式实现：

cpp复制auto cmd = ModernCommand(
    []{ std::cout << "Executing\n"; },
    []{ std::cout << "Undoing\n"; }
);
cmd.execute();
cmd.undo();

7. 设计模式组合实践

7.1 命令+组合模式=宏命令

实现可以包含子命令的宏命令：

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

7.2 命令+备忘录模式=完美撤销

结合备忘录模式实现更可靠的撤销机制：

cpp复制class Memento {
    // 保存对象状态
};

class Originator {
    // 业务对象
public:
    std::unique_ptr<Memento> save() {
        // 创建备忘录
    }
    
    void restore(const Memento* m) {
        // 从备忘录恢复
    }
};

class MementoCommand : public Command {
    Originator* originator_;
    std::unique_ptr<Memento> memento_;
public:
    void execute() override {
        memento_ = originator_->save();
        // 执行操作
    }
    
    void undo() override {
        originator_->restore(memento_.get());
    }
};

8. 实际项目中的经验总结

经过多个项目实践，我总结了以下宝贵经验：

1. 接口设计原则：

   • 保持命令接口简单（通常只需要execute/undo）
   • 避免在命令接口中添加业务逻辑
   • 考虑将命令参数化而非创建大量子类

2. 性能考量：

   • 对于高频命令，考虑使用内存池
   • 轻量级命令优先使用值语义
   • 避免在命令构造函数中执行耗时操作

3. 可维护性建议：

   • 为每个命令类添加详细的注释
   • 实现命令的序列化/反序列化以便调试
   • 使用工厂模式管理命令创建

4. 测试策略：

   • 为每个命令编写单元测试
   • 测试撤销操作的正确性
   • 验证命令的组合效果

cpp复制// 命令工厂示例
class CommandFactory {
public:
    std::unique_ptr<Command> createMoveCommand(Character* c, int x, int y) {
        return std::make_unique<MoveCommand>(c, x, y);
    }
    
    std::unique_ptr<Command> createAttackCommand(Character* src, Character* target) {
        return std::make_unique<AttackCommand>(src, target);
    }
};

在大型项目中，命令模式往往与其他模式协同工作。比如在游戏引擎中，我经常将命令模式与观察者模式结合，实现事件驱动的架构。命令对象作为事件的具体载体，通过事件总线分发，接收者订阅特定类型的命令事件。这种架构既保持了松耦合，又能实现复杂的交互逻辑。