命令模式，餐厅订单管理系统C++

一、为什么用命令模式

在软件设计中，命令模式（Command Pattern）提供了一种将请求封装为对象的方式，从而使请求的发送者和执行者解耦。这在以下场景非常有用：当操作需要支持撤销、排队、延迟执行或日志记录时，命令模式能将逻辑统一管理。

餐厅点餐系统是典型场景：服务员记录顾客订单，厨师按顺序制作，每道菜可独立撤销或取消，但正在制作的菜不能撤销。直接在服务员或厨师中处理复杂逻辑，会导致代码耦合，难以扩展。使用命令模式，将"下单""做菜""撤销"操作封装成独立命令对象，既清晰又易维护。

二、场景说明

在这个场景中，餐厅的服务员负责接收顾客点餐。每道菜都是一个独立的命令对象，例如"红烧鱼"和"家乡煎豆腐"。顾客下单后，服务员将订单加入队列，但厨师是按顺序做菜的，当前只做一道菜，做完后才开始下一道。

系统支持顾客在下单后撤销某些菜，但有严格限制：正在烹饪的菜不可撤销，只允许撤销尚未开始的菜。服务员可以继续接收新订单，撤销旧订单，厨师按照队列顺序烹饪所有菜品。这样既满足实际业务需求，也充分体现了命令模式的灵活性和可扩展性。

三、类图

四、C++代码实现

cpp 复制代码

#include <iostream>
#include <memory>
#include <map>
#include <deque>
#include <algorithm>

enum class OrderStatus { Pending, Cooking, Done };

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

// 厨师
class Chef {
public:
    void cookFish() { std::cout << "厨师：开始做红烧鱼！\n"; }
    void cancelFish() { std::cout << "厨师：取消红烧鱼。\n"; }

    void cookTofu() { std::cout << "厨师：开始做家乡煎豆腐！\n"; }
    void cancelTofu() { std::cout << "厨师：取消家乡煎豆腐。\n"; }
};

// 具体命令
class FishCommand : public Command {
public:
    FishCommand(Chef* chef) : chef_(chef) {}
    void execute() override { chef_->cookFish(); }
    void undo() override { chef_->cancelFish(); }
private:
    Chef* chef_;
};

class TofuCommand : public Command {
public:
    TofuCommand(Chef* chef) : chef_(chef) {}
    void execute() override { chef_->cookTofu(); }
    void undo() override { chef_->cancelTofu(); }
private:
    Chef* chef_;
};

// 服务员
class Waiter {
public:
    int takeOrder(std::unique_ptr<Command> cmd) {
        int id = nextId_++;
        orders_[id] = { std::move(cmd), OrderStatus::Pending };
        orderQueue_.push_back(id);
        std::cout << "服务员：记录订单编号 " << id << "\n";
        cookNextIfIdle();
        return id;
    }

    void cancelOrder(int id) {
        auto it = orders_.find(id);
        if (it != orders_.end()) {
            if (it->second.status == OrderStatus::Pending) {
                it->second.command->undo();
                orderQueue_.erase(
                    std::remove(orderQueue_.begin(), orderQueue_.end(), id),
                    orderQueue_.end()
                );
                orders_.erase(it);
            } else {
                std::cout << "订单 " << id << " 正在做或已完成，无法撤销。\n";
            }
        } else {
            std::cout << "没有找到编号为 " << id << " 的订单。\n";
        }
    }

private:
    struct OrderItem {
        std::unique_ptr<Command> command;
        OrderStatus status;
    };

    void cookNextIfIdle() {
        if (isCooking_ || orderQueue_.empty()) return;
        isCooking_ = true;
        while (!orderQueue_.empty()) {
            int id = orderQueue_.front();
            orderQueue_.pop_front();
            auto it = orders_.find(id);
            if (it != orders_.end()) {
                it->second.status = OrderStatus::Cooking;
                it->second.command->execute();
                it->second.status = OrderStatus::Done;
                orders_.erase(it); 
            }
        }
        isCooking_ = false;
        std::cout << "厨师：所有订单已完成。\n";
    }

    int nextId_ = 1;
    bool isCooking_ = false;
    std::map<int, OrderItem> orders_;
    std::deque<int> orderQueue_;
};

// 测试
int main() {
    Chef chef;
    Waiter waiter;

    int o1 = waiter.takeOrder(std::make_unique<FishCommand>(&chef));
    int o2 = waiter.takeOrder(std::make_unique<TofuCommand>(&chef));
    int o3 = waiter.takeOrder(std::make_unique<FishCommand>(&chef));

    waiter.cancelOrder(o2); // 可以取消豆腐，只要它还没开始做
    int o4 = waiter.takeOrder(std::make_unique<TofuCommand>(&chef)); // 新下单豆腐

    return 0;
}

五、总结

通过这个餐厅点餐示例，我们可以看到命令模式在实际开发中的几个优势：

解耦请求和执行：服务员只负责接单和管理订单，厨师专注于烹饪逻辑，二者职责清晰分明。
支持撤销与延迟操作：每道菜都是独立的命令对象，未开始的菜可以随时取消，而正在烹饪的菜则安全执行。
扩展性强：增加新菜品只需创建新的命令类，无需修改服务员或厨师核心逻辑，符合开闭原则。
维护方便：通过订单状态管理和队列处理，烹饪顺序和撤销逻辑清晰可控。

这个示例不仅清楚地展示了命令模式的用法，也贴合实际餐厅点餐流程，对于想在 C++ 项目中灵活运用设计模式的开发者，很有参考意义。