1. 命令模式在C++中的核心价值
作为一名长期奋战在C++一线的开发者，我亲历过太多因业务逻辑与界面操作强耦合而导致的维护噩梦。命令模式（Command Pattern）正是解决这类问题的银弹——它将请求封装为独立对象，使你可以参数化客户端与不同请求。简单来说，就是把"做什么"和"谁来做"解耦。
在游戏开发中，我们常用它来处理玩家输入。比如一个按键可能触发攻击、跳跃或使用道具等不同行为。通过命令对象队列，还能轻松实现撤销/重做功能——这是GUI编辑器和高频交易系统的标配能力。
关键理解：命令对象本质是携带执行上下文的方法调用。它把操作细节封装在execute()方法里，调用者只需知道"执行命令"而无需了解具体实现。
2. 典型场景与UML结构解析
2.1 高频应用场景
- 多级撤销系统：文本编辑器中的操作历史栈
- 任务队列：线程池的任务调度系统
- 宏命令：批量执行一组命令
- 事务系统：要么全部成功，要么回滚所有操作
2.2 UML核心元素
class Diagram { class Invoker { -commands: Command[] +storeCommand(c: Command) +executeCommands() } interface Command { <<interface>> +execute() +undo() } class ConcreteCommand { -receiver: Receiver -state: SomeType +execute() +undo() } class Receiver { +action() } Invoker o--> Command ConcreteCommand ..|> Command ConcreteCommand --> Receiver }3. 完整实现案例：游戏技能系统
3.1 基础命令接口
class Command { public: virtual ~Command() = default; virtual void execute() = 0; virtual void undo() = 0; };3.2 具体技能命令
class FireballCommand : public Command { Character& receiver_; int manaCost_; Point target_; public: FireballCommand(Character& receiver, Point target) : receiver_(receiver), target_(target), manaCost_(30) {} void execute() override { if(receiver_.mana >= manaCost_) { receiver_.castFireball(target_); receiver_.mana -= manaCost_; } } void undo() override { receiver_.mana += manaCost_; // 需要实现技能效果回滚逻辑 } };3.3 命令管理类
class InputHandler { std::stack<std::unique_ptr<Command>> history_; public: void handleInput(Command* cmd) { cmd->execute(); history_.push(std::unique_ptr<Command>(cmd)); } void undoLastCommand() { if(!history_.empty()) { history_.top()->undo(); history_.pop(); } } };4. 高级应用技巧
4.1 复合命令模式
class MacroCommand : public Command { std::vector<std::unique_ptr<Command>> commands_; public: void addCommand(Command* cmd) { commands_.emplace_back(cmd); } void execute() override { for(auto& cmd : commands_) { cmd->execute(); } } void undo() override { for(auto it = commands_.rbegin(); it != commands_.rend(); ++it) { (*it)->undo(); } } };4.2 性能优化方案
- 对象池技术：对高频创建的命令对象使用对象池
- 惰性初始化：推迟参数的实际绑定时机
- 命令合并：将多个相似命令合并为单个批处理命令
5. 实战中的坑与解决方案
5.1 内存管理陷阱
// 错误示例：原始指针导致内存泄漏 void badExample() { Command* cmd = new FireballCommand(player, target); handler.handleInput(cmd); // 如果handleInput内部没有delete，就会泄漏 } // 正确做法：使用智能指针 void goodExample() { auto cmd = std::make_unique<FireballCommand>(player, target); handler.handleInput(cmd.release()); // 转移所有权 }5.2 线程安全问题
当命令队列被多线程访问时：
- 使用std::mutex保护命令栈
- 考虑无锁队列（如boost::lockfree::queue）
- 避免在命令中持有共享状态
6. 现代C++的改进实现
6.1 使用std::function
class FunctionCommand { std::function<void()> execute_; std::function<void()> undo_; public: template <typename Exec, typename Undo> FunctionCommand(Exec&& exec, Undo&& undo) : execute_(std::forward<Exec>(exec)) , undo_(std::forward<Undo>(undo)) {} void execute() { execute_(); } void undo() { undo_(); } }; // 使用示例 auto cmd = FunctionCommand( [&player] { player.jump(); }, [&player] { player.undoJump(); } );6.2 配合可变参数模板
template <typename Receiver, typename... Args> class GenericCommand { using Action = void (Receiver::*)(Args...); Receiver& receiver_; Action action_; std::tuple<Args...> args_; public: GenericCommand(Receiver& receiver, Action action, Args&&... args) : receiver_(receiver), action_(action), args_(std::forward<Args>(args)...) {} void execute() { std::apply([this](auto&&... args) { (receiver_.*action_)(std::forward<decltype(args)>(args)...); }, args_); } };7. 设计模式组合实践
7.1 配合工厂模式
class CommandFactory { public: std::unique_ptr<Command> createCommand(CommandType type, Character& target) { switch(type) { case FIREBALL: return std::make_unique<FireballCommand>(target); case HEAL: return std::make_unique<HealCommand>(target); // ... default: throw std::invalid_argument("Unknown command type"); } } };7.2 与观察者模式联用
class CommandLogger : public Command { Command& wrapped_; std::ostream& logger_; public: CommandLogger(Command& cmd, std::ostream& out) : wrapped_(cmd), logger_(out) {} void execute() override { logger_ << "Executing command at " << std::time(nullptr); wrapped_.execute(); } void undo() override { logger_ << "Undoing command at " << std::time(nullptr); wrapped_.undo(); } };在大型C++项目中，命令模式常常与备忘录模式配合实现完美的撤销系统。我曾在某个CAD软件项目中，通过这种组合将撤销栈的内存占用降低了40%——关键是把命令对象中的状态改为共享指针，让多个命令可以引用同一份数据快照。
