C++命令模式实战：解耦请求与执行的艺术

1. 命令模式：解耦请求与执行的利器

第一次在大型C++项目中遇到命令模式，是在一个图形编辑器里。当时我们需要实现一个支持撤销/重做的复杂绘图系统，团队成员对如何优雅地处理用户操作产生了分歧。有人提议用简单的switch-case判断操作类型，但当我们看到随着功能增加，代码迅速膨胀到3000行的command.cpp文件时，终于意识到需要更结构化的解决方案。

命令模式的核心价值在于将"做什么"（请求内容）与"怎么做"（执行细节）解耦。想象餐厅点餐的场景：顾客（调用者）只需要告诉服务员（调用对象）想要什么菜（命令），而不必关心厨师（接收者）具体如何烹饪。这种间接性带来了惊人的灵活性——我们可以把命令对象像数据一样存储、排队、记录，甚至在不同线程间传递。

在C++中实现命令模式时，通常会定义这样的基础结构：

cpp复制class Command {
public:
    virtual ~Command() = default;
    virtual void execute() = 0;
    virtual void undo() = 0;  // 支持撤销操作
};

这个抽象接口就像给所有具体操作订立了契约，确保它们都能以统一的方式被执行和撤销。对于需要参数的命令，我们通常会在具体命令类的构造函数中注入这些依赖：

cpp复制class DrawCircleCommand : public Command {
    Canvas& receiver_;
    Point center_;
    double radius_;
public:
    DrawCircleCommand(Canvas& receiver, Point center, double radius)
        : receiver_(receiver), center_(center), radius_(radius) {}
    
    void execute() override {
        receiver_.drawCircle(center_, radius_);
    }
    
    void undo() override {
        receiver_.eraseCircle(center_, radius_);
    }
};

关键设计原则：命令对象应该是无状态的（除了必要的参数），执行结果应完全依赖于接收者的状态。这使得命令可以像值一样被安全地传递和复用。

2. 实战中的四种典型实现变体

2.1 基础实现：图形编辑器案例

在图形编辑器中，我们为每个操作创建了具体命令类。比如移动元素命令：

cpp复制class MoveElementCommand : public Command {
    Editor& editor_;
    ElementID element_;
    Point delta_;
    Point originalPos_;
public:
    MoveElementCommand(Editor& editor, ElementID element, Point delta)
        : editor_(editor), element_(element), delta_(delta) {}
    
    void execute() override {
        originalPos_ = editor_.getPosition(element_);
        editor_.setPosition(element_, originalPos_ + delta_);
    }
    
    void undo() override {
        editor_.setPosition(element_, originalPos_);
    }
};

使用示例：

cpp复制Editor editor;
auto cmd = std::make_unique<MoveElementCommand>(editor, selectedElement, {10, 0});
cmd->execute();  // 执行移动
commandHistory.push(std::move(cmd));  // 存入历史记录

2.2 复合命令：宏操作支持

当需要把多个命令作为一个原子操作执行时，复合命令模式大显身手：

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();
        }
    }
};

这个设计允许我们创建像"组合图形"这样的复杂操作，同时保持单个命令的独立性。

2.3 函数式命令：C++11的lambda力量

现代C++允许我们用更简洁的方式实现命令模式：

cpp复制class FunctionalCommand : public Command {
    std::function<void()> execute_;
    std::function<void()> undo_;
public:
    FunctionalCommand(std::function<void()> execute, 
                     std::function<void()> undo)
        : execute_(execute), undo_(undo) {}
    
    void execute() override { execute_(); }
    void undo() override { undo_(); }
};

使用示例：

cpp复制int value = 0;
auto cmd = std::make_unique<FunctionalCommand>(
    [&value] { value = 42; },  // execute
    [&value, old=value] { value = old; }  // undo
);

这种方式特别适合简单命令，避免了为每个操作创建单独类的开销。

2.4 异步命令：线程池集成

在多线程环境中，我们可以扩展命令模式来实现任务队列：

cpp复制class AsyncCommand : public Command {
    std::promise<void> promise_;
    std::function<void()> work_;
public:
    AsyncCommand(std::function<void()> work) : work_(work) {}
    
    std::future<void> getFuture() { return promise_.get_future(); }
    
    void execute() override {
        try {
            work_();
            promise_.set_value();
        } catch (...) {
            promise_.set_exception(std::current_exception());
        }
    }
    
    void undo() override {}  // 异步命令通常不可撤销
};

线程池可以这样消费命令：

cpp复制while (auto cmd = queue.pop()) {
    cmd->execute();
}

3. 性能优化与内存管理

3.1 命令对象池化

频繁创建/销毁命令对象可能导致内存碎片。我们可以使用对象池模式：

cpp复制template <typename T>
class CommandPool {
    std::queue<std::unique_ptr<T>> pool_;
public:
    template <typename... Args>
    std::unique_ptr<T> acquire(Args&&... args) {
        if (pool_.empty()) {
            return std::make_unique<T>(std::forward<Args>(args)...);
        }
        auto cmd = std::move(pool_.front());
        pool_.pop();
        cmd->reset(std::forward<Args>(args)...);  // 假设命令有reset方法
        return cmd;
    }
    
    void release(std::unique_ptr<T> cmd) {
        pool_.push(std::move(cmd));
    }
};

3.2 小型命令优化

对于极简单的命令，可以考虑用内存更高效的实现：

cpp复制class LightweightCommand {
    using CommandFunc = void(*)(void*);
    CommandFunc execute_;
    CommandFunc undo_;
    void* data_;
public:
    template <typename T>
    LightweightCommand(T* obj, 
                      void(T::*exec)(), 
                      void(T::*undo)())
        : execute_([](void* d) { (static_cast<T*>(d)->*exec)(); }),
          undo_([](void* d) { (static_cast<T*>(d)->*undo)(); }),
          data_(obj) {}
    
    void execute() { execute_(data_); }
    void undo() { undo_(data_); }
};

4. 实际工程中的挑战与解决方案

4.1 撤销/重做栈的实现

一个健壮的撤销系统需要考虑：

cpp复制class CommandHistory {
    std::stack<std::unique_ptr<Command>> undoStack_;
    std::stack<std::unique_ptr<Command>> redoStack_;
    size_t maxDepth_ = 100;
public:
    void execute(std::unique_ptr<Command> cmd) {
        cmd->execute();
        undoStack_.push(std::move(cmd));
        if (undoStack_.size() > maxDepth_) {
            undoStack_.pop();  // 丢弃最旧命令
        }
        // 执行新命令后清空重做栈
        redoStack_ = std::stack<std::unique_ptr<Command>>();
    }
    
    void undo() {
        if (undoStack_.empty()) return;
        auto cmd = std::move(undoStack_.top());
        undoStack_.pop();
        cmd->undo();
        redoStack_.push(std::move(cmd));
    }
    
    void redo() {
        if (redoStack_.empty()) return;
        auto cmd = std::move(redoStack_.top());
        redoStack_.pop();
        cmd->execute();
        undoStack_.push(std::move(cmd));
    }
};

4.2 命令序列化与持久化

为了实现保存/加载功能，我们需要扩展命令接口：

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

class CreateRectangleCommand : public SerializableCommand {
    Rect rect_;
public:
    std::string serialize() const override {
        return fmt::format("CREATE_RECT {} {} {} {}", 
                         rect_.x, rect_.y, rect_.width, rect_.height);
    }
    
    static std::unique_ptr<CreateRectangleCommand> deserialize(const std::string& s) {
        // 解析字符串...
    }
};

4.3 事务处理与错误恢复

在数据库类应用中，命令模式可以实现事务：

cpp复制class Transaction {
    std::vector<std::unique_ptr<Command>> commands_;
    bool committed_ = false;
public:
    void addCommand(std::unique_ptr<Command> cmd) {
        if (committed_) throw std::runtime_error("Transaction already committed");
        commands_.push_back(std::move(cmd));
    }
    
    void commit() {
        try {
            for (auto& cmd : commands_) {
                cmd->execute();
            }
            committed_ = true;
        } catch (...) {
            rollback();
            throw;
        }
    }
    
    void rollback() {
        for (auto it = commands_.rbegin(); it != commands_.rend(); ++it) {
            (*it)->undo();
        }
    }
};

5. 现代C++特性在命令模式中的应用

5.1 使用std::variant实现类型安全命令

C++17的variant可以创建类型安全的命令系统：

cpp复制using CommandData = std::variant<
    MoveData, 
    DrawData, 
    DeleteData
>;

class VariantCommand {
    CommandData data_;
    void (*execute_)(CommandData&);
    void (*undo_)(CommandData&);
public:
    template <typename T>
    VariantCommand(T data)
        : data_(std::move(data)),
          execute_([](CommandData& d) { std::get<T>(d).execute(); }),
          undo_([](CommandData& d) { std::get<T>(d).undo(); }) {}
    
    void execute() { execute_(data_); }
    void undo() { undo_(data_); }
};

5.2 协程与异步命令

C++20协程为异步命令提供了新可能：

cpp复制struct AwaitableCommand {
    Command& cmd_;
    bool await_ready() const { return false; }
    void await_suspend(std::coroutine_handle<> h) {
        threadPool.enqueue([this, h] {
            cmd_.execute();
            h.resume();
        });
    }
    void await_resume() {}
};

Task<> asyncOperation() {
    DrawCommand draw(...);
    co_await AwaitableCommand{draw};
    // 绘制完成后继续...
}

5.3 概念约束与命令接口

C++20概念可以更好地约束命令类型：

cpp复制template <typename T>
concept CommandConcept = requires(T cmd) {
    { cmd.execute() } -> std::same_as<void>;
    { cmd.undo() } -> std::same_as<void>;
};

template <CommandConcept Cmd>
void processCommand(Cmd&& cmd) {
    cmd.execute();
    // ...
}

6. 测试策略与调试技巧

6.1 单元测试命令对象

使用Google Test框架测试命令：

cpp复制TEST(CommandTest, MoveCommandExecution) {
    TestCanvas canvas;
    canvas.addElement({0, 0});
    MoveCommand cmd(canvas, 0, {10, 5});
    
    cmd.execute();
    EXPECT_EQ(canvas.getElement(0).position, (Point{10, 5}));
    
    cmd.undo();
    EXPECT_EQ(canvas.getElement(0).position, (Point{0, 0}));
}

6.2 模拟接收者对象

使用gmock创建mock接收者：

cpp复制class MockCanvas : public Canvas {
public:
    MOCK_METHOD(void, drawCircle, (Point center, double radius), (override));
    MOCK_METHOD(void, eraseCircle, (Point center, double radius), (override));
};

TEST(CommandTest, DrawCircleCommandCallsCorrectMethods) {
    MockCanvas canvas;
    EXPECT_CALL(canvas, drawCircle(Point{10,20}, 5.0)).Times(1);
    EXPECT_CALL(canvas, eraseCircle(Point{10,20}, 5.0)).Times(1);
    
    DrawCircleCommand cmd(canvas, {10,20}, 5.0);
    cmd.execute();
    cmd.undo();
}

6.3 内存泄漏检测

在命令历史记录中检测内存泄漏：

cpp复制struct CommandTracker {
    static inline int count = 0;
    CommandTracker() { ++count; }
    ~CommandTracker() { --count; }
};

class TrackedCommand : public Command {
    CommandTracker tracker_;
    // ... 其他实现
};

TEST(CommandTest, MemoryLeakCheck) {
    {
        CommandHistory history;
        history.execute(std::make_unique<TrackedCommand>(...));
        EXPECT_EQ(CommandTracker::count, 1);
    }
    EXPECT_EQ(CommandTracker::count, 0);  // 确保所有命令被销毁
}

7. 与其他设计模式的协同

7.1 组合模式实现宏命令

cpp复制class CompositeCommand : public Command {
    std::vector<std::shared_ptr<Command>> children_;
public:
    void add(const std::shared_ptr<Command>& cmd) {
        children_.push_back(cmd);
    }
    
    void execute() override {
        for (auto& cmd : children_) {
            cmd->execute();
        }
    }
    
    void undo() override {
        for (auto it = children_.rbegin(); it != children_.rend(); ++it) {
            (*it)->undo();
        }
    }
};

7.2 备忘录模式保存状态

cpp复制class Memento {
    friend class Originator;
    State state_;
    explicit Memento(const State& s) : state_(s) {}
public:
    State getState() const { return state_; }
};

class Originator {
    State state_;
public:
    Memento save() const { return Memento(state_); }
    void restore(const Memento& m) { state_ = m.getState(); }
};

class StatefulCommand : public Command {
    Originator& originator_;
    Memento before_;
public:
    StatefulCommand(Originator& o) : originator_(o), before_(o.save()) {}
    
    void undo() override {
        originator_.restore(before_);
    }
};

7.3 观察者模式通知命令执行

cpp复制class CommandNotifier {
    std::vector<std::function<void(Command&)>> observers_;
public:
    void subscribe(std::function<void(Command&)> observer) {
        observers_.push_back(observer);
    }
    
    void notify(Command& cmd) {
        for (auto& obs : observers_) {
            obs(cmd);
        }
    }
};

class ObservableCommand : public Command {
    CommandNotifier& notifier_;
    std::unique_ptr<Command> wrapped_;
public:
    void execute() override {
        wrapped_->execute();
        notifier_.notify(*this);
    }
    // ... 其他方法
};

8. 性能对比与适用场景分析

8.1 各种实现方式的性能指标

我们在100万次命令执行的测试中得到以下数据（单位：ms）：

8.2 典型应用场景推荐

1. GUI应用：需要撤销/重做功能时，经典虚函数实现最合适
2. 游戏开发：对性能敏感的场景，函数指针+void*可能是最佳选择
3. 服务器应用：需要异步处理时，协程实现提供了最佳可读性
4. 脚本系统：variant实现提供了最大的灵活性
5. 嵌入式系统：函数指针实现内存占用最小

8.3 何时不使用命令模式

在以下情况下，命令模式可能不是最佳选择：

• 操作极其简单且不需要撤销功能
• 性能是绝对关键因素且命令执行频率极高
• 命令与接收者之间存在固定的1:1关系
• 系统已经非常复杂，引入命令模式会增加不必要的抽象层

9. 真实项目案例：文本编辑器实现

让我们看一个简化版文本编辑器的完整实现：

cpp复制class TextEditor {
    std::string text_;
    size_t cursor_ = 0;
public:
    void insert(char c) {
        text_.insert(cursor_++, 1, c);
    }
    
    void backspace() {
        if (cursor_ > 0) {
            text_.erase(--cursor_, 1);
        }
    }
    
    void moveLeft() { if (cursor_ > 0) --cursor_; }
    void moveRight() { if (cursor_ < text_.size()) ++cursor_; }
    
    const std::string& getText() const { return text_; }
    size_t getCursor() const { return cursor_; }
};

class EditorCommand : public Command {
protected:
    TextEditor& editor_;
public:
    EditorCommand(TextEditor& editor) : editor_(editor) {}
};

class InsertCommand : public EditorCommand {
    char char_;
public:
    InsertCommand(TextEditor& editor, char c) 
        : EditorCommand(editor), char_(c) {}
    
    void execute() override { editor_.insert(char_); }
    void undo() override { editor_.backspace(); }
};

// 其他命令类实现类似...

class TextEditorApp {
    TextEditor editor_;
    CommandHistory history_;
public:
    void type(char c) {
        auto cmd = std::make_unique<InsertCommand>(editor_, c);
        history_.execute(std::move(cmd));
    }
    
    void backspace() {
        auto cmd = std::make_unique<BackspaceCommand>(editor_);
        history_.execute(std::move(cmd));
    }
    
    void undo() { history_.undo(); }
    void redo() { history_.redo(); }
};

10. 进阶技巧与最佳实践

10.1 命令的不可变性设计

良好的命令实现应该是不可变的：

cpp复制class ImmutableCommand {
    const Receiver& receiver_;
    const Params params_;
public:
    ImmutableCommand(const Receiver& r, Params p)
        : receiver_(r), params_(std::move(p)) {}
    
    void execute() const { receiver_.action(params_); }
    // ... 其他方法
};

这种设计保证了：

• 线程安全性：命令可以在不同线程间安全传递
• 可预测性：执行结果只依赖于初始状态
• 易于调试：命令参数在执行过程中不会改变

10.2 基于原型的命令创建

对于需要频繁创建相似命令的场景：

cpp复制class CommandPrototype {
    std::unordered_map<std::type_index, std::unique_ptr<Command>> prototypes_;
public:
    template <typename T, typename... Args>
    void registerPrototype(Args&&... args) {
        prototypes_[typeid(T)] = std::make_unique<T>(std::forward<Args>(args)...);
    }
    
    template <typename T>
    std::unique_ptr<T> clone() const {
        auto it = prototypes_.find(typeid(T));
        if (it == prototypes_.end()) return nullptr;
        return std::unique_ptr<T>(static_cast<T*>(it->second->clone()));
    }
};

10.3 基于策略的命令执行

允许动态改变命令执行策略：

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

class ImmediatePolicy : public ExecutionPolicy {
    void execute(Command& cmd) override { cmd.execute(); }
};

class LoggingPolicy : public ExecutionPolicy {
    std::ostream& log_;
    std::unique_ptr<ExecutionPolicy> inner_;
public:
    LoggingPolicy(std::ostream& log, std::unique_ptr<ExecutionPolicy> inner)
        : log_(log), inner_(std::move(inner)) {}
    
    void execute(Command& cmd) override {
        log_ << "Executing: " << typeid(cmd).name() << "\n";
        inner_->execute(cmd);
    }
};

class CommandExecutor {
    std::unique_ptr<ExecutionPolicy> policy_;
public:
    void setPolicy(std::unique_ptr<ExecutionPolicy> policy) {
        policy_ = std::move(policy);
    }
    
    void execute(Command& cmd) {
        if (!policy_) policy_ = std::make_unique<ImmediatePolicy>();
        policy_->execute(cmd);
    }
};

11. 常见陷阱与解决方案

11.1 命令与接收者的生命周期管理

常见错误：

cpp复制// 危险！接收者可能比命令先销毁
auto cmd = new DrawCommand(someCanvas, ...);

安全做法：

cpp复制// 使用shared_ptr管理共享接收者
auto receiver = std::make_shared<Canvas>();
auto cmd = std::make_unique<DrawCommand>(receiver, ...);

11.2 不可逆命令的处理

对于不可撤销的命令，应该明确标识：

cpp复制class IrreversibleCommand : public Command {
public:
    void undo() override {
        throw std::logic_error("This command cannot be undone");
    }
};

11.3 命令执行失败的处理策略

健壮的执行策略应该包括：

cpp复制void safeExecute(Command& cmd) {
    try {
        cmd.execute();
    } catch (const std::exception& e) {
        logError(e.what());
        try {
            cmd.undo();  // 尝试回滚
        } catch (...) {
            // 处理回滚失败
        }
        throw;  // 重新抛出异常
    }
}

12. 现代C++项目中的实践建议

12.1 使用智能指针管理命令对象

推荐使用std::unique_ptr作为命令的基本持有方式：

cpp复制using CommandPtr = std::unique_ptr<Command>;

class CommandProcessor {
    std::vector<CommandPtr> commands_;
public:
    void addCommand(CommandPtr cmd) {
        commands_.push_back(std::move(cmd));
    }
    
    void processAll() {
        for (auto& cmd : commands_) {
            cmd->execute();
        }
    }
};

12.2 利用移动语义优化性能

设计可移动的命令类：

cpp复制class MovableCommand : public Command {
    std::vector<int> largeData_;
public:
    MovableCommand(std::vector<int> data) 
        : largeData_(std::move(data)) {}  // 使用移动构造
    
    MovableCommand(MovableCommand&&) = default;
    MovableCommand& operator=(MovableCommand&&) = default;
    
    // ... 其他实现
};

12.3 使用type-erasure处理异构命令集合

当需要存储不同类型的命令时：

cpp复制class AnyCommand {
    struct Concept {
        virtual ~Concept() = default;
        virtual void execute() = 0;
        virtual void undo() = 0;
    };
    
    template <typename T>
    struct Model : Concept {
        T impl_;
        Model(T impl) : impl_(std::move(impl)) {}
        void execute() override { impl_.execute(); }
        void undo() override { impl_.undo(); }
    };
    
    std::unique_ptr<Concept> impl_;
public:
    template <typename T>
    AnyCommand(T impl) : impl_(std::make_unique<Model<T>>(std::move(impl))) {}
    
    void execute() { impl_->execute(); }
    void undo() { impl_->undo(); }
};

13. 跨平台开发的注意事项

13.1 平台相关命令的实现

使用工厂方法隔离平台相关代码：

cpp复制class PlatformCommandFactory {
public:
    virtual std::unique_ptr<Command> createFileOpenCommand() = 0;
    // ... 其他平台相关命令
};

class WindowsCommandFactory : public PlatformCommandFactory {
    std::unique_ptr<Command> createFileOpenCommand() override {
        return std::make_unique<WindowsFileOpenCommand>();
    }
};

13.2 命令序列化的跨平台兼容性

确保序列化格式跨平台一致：

cpp复制struct CommandSerialization {
    uint32_t magic;      // 固定魔数标识
    uint16_t version;    // 格式版本
    uint16_t type;       // 命令类型
    uint32_t dataSize;   // 数据部分大小
    // 后面跟着变长数据
};

void serializeCommand(const Command& cmd, std::ostream& out) {
    CommandSerialization header{
        .magic = 0xDEC0DE,
        .version = 1,
        .type = cmd.getType(),
        .dataSize = cmd.getSerializedSize()
    };
    out.write(reinterpret_cast<char*>(&header), sizeof(header));
    cmd.serialize(out);
}

13.3 原子性操作的平台差异处理

对于需要原子性执行的操作：

cpp复制class AtomicCommand : public Command {
    std::vector<std::unique_ptr<Command>> commands_;
public:
    void execute() override {
        #ifdef _WIN32
        // Windows下的原子性实现
        #else
        // Linux/macOS下的原子性实现
        #endif
    }
};

14. 性能关键系统中的优化技巧

14.1 命令预分配与内存池

cpp复制template <typename CommandType>
class CommandAllocator {
    std::vector<std::unique_ptr<CommandType>> pool_;
public:
    template <typename... Args>
    CommandType* allocate(Args&&... args) {
        if (pool_.empty()) {
            pool_.reserve(100);
            for (int i = 0; i < 100; ++i) {
                pool_.push_back(std::make_unique<CommandType>());
            }
        }
        auto cmd = pool_.back().release();
        pool_.pop_back();
        new (cmd) CommandType(std::forward<Args>(args)...);
        return cmd;
    }
    
    void deallocate(CommandType* cmd) {
        cmd->~CommandType();
        pool_.emplace_back(cmd);
    }
};

14.2 热路径命令的内联优化

对于高频执行的简单命令：

cpp复制class InlineCommand final : public Command {
    Receiver* receiver_;
    Param param_;
public:
    __attribute__((always_inline))
    void execute() override {
        receiver_->fastPath(param_);
    }
    // ... 其他方法
};

14.3 无锁命令队列实现

cpp复制template <typename T>
class LockFreeCommandQueue {
    struct Node {
        std::atomic<Node*> next;
        T data;
    };
    
    std::atomic<Node*> head_;
    std::atomic<Node*> tail_;
public:
    void push(T cmd) {
        Node* newNode = new Node{nullptr, std::move(cmd)};
        Node* oldTail = tail_.exchange(newNode, std::memory_order_acq_rel);
        oldTail->next.store(newNode, std::memory_order_release);
    }
    
    bool pop(T& result) {
        Node* oldHead = head_.load(std::memory_order_relaxed);
        Node* next = oldHead->next.load(std::memory_order_acquire);
        if (!next) return false;
        result = std::move(next->data);
        head_.store(next, std::memory_order_release);
        delete oldHead;
        return true;
    }
};

15. 调试复杂命令系统的工具与技术

15.1 命令执行追踪

cpp复制class TracingCommandProxy : public Command {
    Command& target_;
    std::ostream& trace_;
public:
    TracingCommandProxy(Command& target, std::ostream& trace)
        : target_(target), trace_(trace) {}
    
    void execute() override {
        trace_ << "BEGIN EXECUTE: " << typeid(target_).name() << "\n";
        auto start = std::chrono::high_resolution_clock::now();
        target_.execute();
        auto end = std::chrono::high_resolution_clock::now();
        trace_ << "END EXECUTE (" 
              << std::chrono::duration_cast<std::chrono::microseconds>(end - start).count()
              << "μs)\n";
    }
    // ... 类似实现undo
};

15.2 可视化命令历史

cpp复制class CommandHistoryVisualizer {
    const CommandHistory& history_;
public:
    void visualize(std::ostream& out) const {
        out << "Undo stack:\n";
        visualizeStack(history_.getUndoStack(), out);
        out << "\nRedo stack:\n";
        visualizeStack(history_.getRedoStack(), out);
    }
private:
    void visualizeStack(const std::stack<std::unique_ptr<Command>>& stack, 
                       std::ostream& out) const {
        // 实际实现需要复制栈来遍历
    }
};

15.3 命令依赖关系分析

cpp复制class CommandDependencyAnalyzer {
    using Graph = std::map<const Command*, std::set<const Command*>>;
    Graph graph_;
public:
    void addCommand(const Command* cmd, const std::vector<const Command*>& deps) {
        graph_[cmd].insert(deps.begin(), deps.end());
    }
    
    std::vector<const Command*> getExecutionOrder() const {
        // 实现拓扑排序算法
    }
};

16. 测试驱动开发(TDD)实践

16.1 测试先行开发命令

cpp复制// 测试用例先行
TEST(DrawCommandTest, ShouldDrawCircleOnCanvas) {
    MockCanvas canvas;
    EXPECT_CALL(canvas, drawCircle(Point{10,10}, 5.0));
    
    DrawCommand cmd(canvas, {10,10}, 5.0);
    cmd.execute();
}

// 然后实现刚好能通过测试的代码
class DrawCommand : public Command {
    Canvas& canvas_;
    Point center_;
    double radius_;
public:
    DrawCommand(Canvas& canvas, Point center, double radius)
        : canvas_(canvas), center_(center), radius_(radius) {}
    
    void execute() override {
        canvas_.drawCircle(center_, radius_);
    }
    // ... 其他方法
};

16.2 行为验证测试

cpp复制TEST(CommandHistoryTest, ShouldUndoCommandsInReverseOrder) {
    StrictMock<MockCommand> cmd1, cmd2;
    InSequence seq;  // 确保调用顺序
    EXPECT_CALL(cmd1, execute());
    EXPECT_CALL(cmd2, execute());
    EXPECT_CALL(cmd2, undo());
    EXPECT_CALL(cmd1, undo());
    
    CommandHistory history;
    history.execute(std::make_unique<MockCommandWrapper>(&cmd1));
    history.execute(std::make_unique<MockCommandWrapper>(&cmd2));
    history.undo();
    history.undo();
}

16.3 模糊测试命令系统

cpp复制void commandFuzzTest() {
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<> cmdTypeDist(0, 3);
    
    TestReceiver receiver;
    CommandHistory history;
    
    for (int i = 0; i < 10000; ++i) {
        auto type = cmdTypeDist(gen);
        std::unique_ptr<Command> cmd;
        
        switch (type) {
            case 0: cmd = std::make_unique<AddCommand>(receiver, gen()); break;
            case 1: cmd = std::make_unique<RemoveCommand>(receiver, gen()); break;
            // ... 其他命令类型
        }
        
        try {
            history.execute(std::move(cmd));
            if (i % 10 == 0) history.undo();
            if (i % 15 == 0) history.redo();
        } catch (...) {
            // 记录错误但继续测试
        }
    }
    
    assert(receiver.consistencyCheck());
}

17. 大型项目中的架构建议

17.1 模块化命令系统设计

cpp复制// commands/core/ 基础接口
class Command { /*...*/ };

// commands/file/ 文件相关命令
class FileCommand : public Command { /*...*/ };

// commands/edit/ 编辑相关命令
class EditCommand : public Command { /*...*/ };

// commands/ 根目录提供工厂和注册机制
class CommandRegistry {
    std::map<std::string, std::function<std::unique_ptr<Command>()>> factories_;
public:
    void registerCommand(const std::string& name, auto factory) {
        factories_[name] = factory;
    }
    
    std::unique_ptr<Command> create(const std::string& name) const {
        return factories_.at(name)();
    }
};

17.2 插件式命令扩展

cpp复制class CommandPlugin {
public:
    virtual ~CommandPlugin() = default;
    virtual void registerCommands(CommandRegistry&) = 0;
};

class DrawingPlugin : public CommandPlugin {
    void registerCommands(CommandRegistry& reg) override {
        reg.registerCommand("draw.line", [] { return std::make_unique<DrawLineCommand>(); });
        // ... 其他绘图命令
    }
};

class Application {
    std::vector<std::unique_ptr<CommandPlugin>> plugins_;
    CommandRegistry registry_;
public:
    void loadPlugin(std::unique_ptr<CommandPlugin> plugin) {
        plugin->registerCommands(registry_);
        plugins_.push_back(std::move(plugin));
    }
};

17.3 分布式命令处理

cpp复制class NetworkCommand : public Command {
    std::string serialized_;
public:
    NetworkCommand(const std::string& serialized) : serialized_(serialized) {}
    
    void execute() override {
        auto parsed = Parser::parse(serialized_);
        parsed->execute();
    }
};

class CommandDispatcher {
    std::vector<std::shared_ptr<CommandQueue>> queues_;
public:
    void dispatch(std::unique_ptr<Command> cmd) {
        auto serialized = cmd->serialize();
        for (auto& queue : queues_) {
            queue->push(std::make_unique<NetworkCommand>(serialized));
        }
    }
};

18. 行业应用案例研究

18.1 图形编辑器中的撤销系统

Adobe Photoshop等专业图形编辑器使用高度优化的命令模式实现：

• 分层命令历史：允许按图层分组撤销
• 轻量级命令：仅存储增量变化而非完整状态
• GPU加速命令：部分绘制命令直接在GPU上执行和撤销

18.2 游戏引擎中的输入处理

Unreal Engine的输入系统特点：

• 输入命令与游戏动作解耦
• 支持按键重映射
• 命令缓冲：在特定游戏阶段执行输入命令

cpp复制class JumpCommand : public Command {
    Character& character_;
public:
    void execute() override {
        if (character_.isOnGround()) {
            character_.setVelocity(0, 0, jumpForce);
        }
    }
};

18.3 金融交易系统中的使用

高频交易系统利用命令模式实现：

• 交易指令的排队与撤销
• 风险控制：命令执行前的预检查
• 审计追踪：所有命令的完整记录

cpp复制class TradeCommand : public Command {
    Account& account_;
    Symbol symbol_;
    int quantity_;