C++命令模式实战：智能家居控制系统开发-嵌云网-嵌入式AI开发资源站

C++命令模式实战：智能家居控制系统开发

趴在黄油上

1. 命令模式实战：用C++打造智能家居控制系统

作为一名有十年经验的C++开发者，我经常遇到需要解耦请求发送者和执行者的场景。命令模式是我工具箱中最实用的设计模式之一，尤其在需要支持撤销、重做或宏命令功能时。今天我就通过一个智能家居控制的完整案例，手把手教你如何用现代C++实现这一模式。

2. 命令模式核心架构解析

2.1 模式角色与职责划分

命令模式的核心在于将请求封装为对象，主要包含五个关键角色：

Command（抽象命令）：定义执行接口的基类，通常包含execute()和undo()方法
ConcreteCommand（具体命令）：实现具体业务逻辑，关联接收者对象
Receiver（接收者）：实际执行业务操作的对象
Invoker（调用者）：触发命令执行，不关心具体实现
Client（客户端）：组装命令对象与接收者

在智能家居场景中：

遥控器按钮就是Invoker
开灯/关灯等操作是ConcreteCommand
灯具、空调等设备是Receiver

2.2 模式优势与应用场景

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

需要回调机制的系统
需要支持撤销/重做操作
需要实现命令队列或日志
需要支持宏命令或事务

我在华为某智能家居项目中就采用此模式，实现了跨品牌设备的统一控制。通过命令模式，我们成功将设备控制逻辑与UI层解耦，新设备接入时间缩短了70%。

3. 完整实现与代码剖析

3.1 基础架构搭建

首先定义抽象命令接口，这是整个模式的核心：

cpp复制// Command.h
#include <memory>
#include <stack>

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

使用智能指针管理资源是现代C++的最佳实践。这里采用std::shared_ptr，因为命令对象可能被多个地方引用。

3.2 接收者实现

接收者是实际执行操作的对象，在智能家居系统中，我们定义灯具和空调：

cpp复制// Receiver.h
#include <iostream>

class Light {
public:
    void on() { std::cout << "Light is ON\n"; }
    void off() { std::cout << "Light is OFF\n"; }
};

class AirConditioner {
public:
    void start() { std::cout << "AC is STARTED\n"; }
    void stop() { std::cout << "AC is STOPPED\n"; }
};

3.3 具体命令实现

每个具体命令绑定一个接收者，实现execute和undo：

cpp复制// ConcreteCommand.h
class LightOnCommand : public Command {
    std::shared_ptr<Light> light;
public:
    explicit LightOnCommand(std::shared_ptr<Light> l) : light(l) {}
    
    void execute() override { light->on(); }
    void undo() override { light->off(); }
};

class AirConditionerOnCommand : public Command {
    std::shared_ptr<AirConditioner> ac;
public:
    explicit AirConditionerOnCommand(std::shared_ptr<AirConditioner> a) : ac(a) {}
    
    void execute() override { ac->start(); }
    void undo() override { ac->stop(); }
};

注意构造函数使用explicit避免隐式转换，这是C++工程实践中的重要细节。

3.4 调用者实现

遥控器作为调用者，维护一个命令历史栈实现撤销功能：

cpp复制// Invoker.h
class RemoteControl {
    std::stack<std::shared_ptr<Command>> history;
public:
    void pressButton(std::shared_ptr<Command> cmd) {
        cmd->execute();
        history.push(cmd);
    }
    
    void pressUndo() {
        if (!history.empty()) {
            history.top()->undo();
            history.pop();
        }
    }
};

使用std::stack实现LIFO（后进先出）的撤销逻辑是最直观的方案。

4. 系统集成与测试

4.1 客户端代码

cpp复制// main.cpp
int main() {
    // 初始化设备
    auto light = std::make_shared<Light>();
    auto ac = std::make_shared<AirConditioner>();
    
    // 创建命令
    auto lightOn = std::make_shared<LightOnCommand>(light);
    auto acOn = std::make_shared<AirConditionerOnCommand>(ac);
    
    // 遥控器操作
    RemoteControl remote;
    remote.pressButton(lightOn);
    remote.pressButton(acOn);
    
    // 测试撤销
    remote.pressUndo();  // 撤销空调
    remote.pressUndo();  // 撤销灯光
    
    return 0;
}

4.2 执行结果分析

程序输出应该是：

code复制Light is ON
AC is STARTED
AC is STOPPED
Light is OFF

这表明我们的撤销功能正常工作，命令按预期顺序执行和回滚。

5. 高级应用与优化

5.1 实现宏命令

宏命令是命令模式的强大扩展，允许将多个命令组合成一个：

cpp复制class MacroCommand : public Command {
    std::vector<std::shared_ptr<Command>> commands;
public:
    void addCommand(std::shared_ptr<Command> cmd) {
        commands.push_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();
        }
    }
};

使用时可以这样组合：

cpp复制auto macro = std::make_shared<MacroCommand>();
macro->addCommand(lightOn);
macro->addCommand(acOn);
remote.pressButton(macro);

5.2 线程安全改进

在多线程环境中，需要对命令历史栈加锁：

cpp复制#include <mutex>

class ThreadSafeRemoteControl {
    std::stack<std::shared_ptr<Command>> history;
    std::mutex mtx;
public:
    void pressButton(std::shared_ptr<Command> cmd) {
        std::lock_guard<std::mutex> lock(mtx);
        cmd->execute();
        history.push(cmd);
    }
    
    void pressUndo() {
        std::lock_guard<std::mutex> lock(mtx);
        if (!history.empty()) {
            history.top()->undo();
            history.pop();
        }
    }
};

6. 工程实践中的经验总结

6.1 性能优化技巧

对象池技术：对于频繁创建/销毁的命令对象，可以使用对象池复用
命令合并：将多个相似命令合并执行，减少开销
异步执行：将耗时命令放入线程池执行

6.2 常见问题排查

内存泄漏：确保所有Command都有虚析构函数
多线程竞争：使用锁或原子操作保护共享数据
撤销栈溢出：设置历史记录的最大深度
命令执行失败：实现回滚机制

6.3 设计权衡考量

类数量膨胀：每个命令都需要一个类，可以用std::function简化
内存占用：历史记录会消耗内存，需要合理清理
执行效率：间接调用会有轻微性能开销

7. 扩展思考与进阶方向

7.1 与其他模式的结合

组合模式：实现树形命令结构
备忘录模式：增强撤销/重做能力
责任链模式：实现命令的链式处理

7.2 实际项目中的应用

在华为智能家居系统中，我们扩展了基础命令模式：

增加了命令优先级机制
实现了分布式命令执行
添加了命令执行超时处理
开发了可视化命令流编辑器