如何实现C++中的命令模式函数对象与std::function的现代替代-C++-PHP中文网

在c++++中实现命令模式，核心在于将请求封装为可调用对象，利用std::function和lambda表达式能显著简化代码并提升灵活性。1. std::function作为命令接口，可统一包装各种可调用对象，如函数、成员函数、lambda等，提供一致调用方式；2. lambda表达式通过捕获列表即时创建命令逻辑，减少冗余类定义，提升代码简洁性和可读性；3. 命令的撤销与重做可通过封装execute_func和undo_func两个std::function实现，并结合历史栈管理操作记录，支持灵活的命令控制。

如何实现C++中的命令模式函数对象与std::function的现代替代

在C++中实现命令模式，特别是利用现代C++特性，核心在于将“请求”抽象成一个可调用的实体。在我看来，最优雅且灵活的方式就是拥抱std::function和Lambda表达式。它们联手提供了一种简洁高效的替代方案，远比传统的多态类继承来得轻便，同时又能保持模式的解耦优势。你不再需要为每个具体的命令动作都写一个单独的类，这大大减少了样板代码。

解决方案

命令模式的本质是将一个操作封装成一个对象，这样你就可以将请求的发送者和接收者解耦，并且能够支持请求的排队、日志记录以及撤销/重做等功能。在现代C++语境下，我们可以将命令的“可执行”接口定义为std::function<void()>。

设想我们有一个Light类，它有turnOn()和turnOff()方法。

立即学习“C++免费学习笔记（深入）”；

#include <iostream>
#include <vector>
#include <string>
#include <functional> // For std::function
#include <memory>     // For std::shared_ptr or std::unique_ptr

// 接收者 (Receiver)
class Light {
private:
    std::string location_;
public:
    Light(const std::string& loc) : location_(loc) {}
    void turnOn() {
        std::cout << location_ << " Light is ON!" << std::endl;
    }
    void turnOff() {
        std::cout << location_ << " Light is OFF!" << std::endl;
    }
};

// 调用者 (Invoker)
class RemoteControl {
private:
    // 命令接口现在是std::function
    std::function<void()> onCommand_;
    std::function<void()> offCommand_;

public:
    void setOnCommand(std::function<void()> cmd) {
        onCommand_ = std::move(cmd);
    }
    void setOffCommand(std::function<void()> cmd) {
        offCommand_ = std::move(cmd);
    }

    void pressOnButton() {
        if (onCommand_) {
            onCommand_();
        } else {
            std::cout << "No ON command set." << std::endl;
        }
    }

    void pressOffButton() {
        if (offCommand_) {
            offCommand_();
        } else {
            std::cout << "No OFF command set." << std::endl;
        }
    }
};

// 客户端代码
int main() {
    std::cout << "--- 现代命令模式示例 ---" << std::endl;

    auto livingRoomLight = std::make_shared<Light>("Living Room");
    auto kitchenLight = std::make_shared<Light>("Kitchen");

    RemoteControl remote;

    // 使用Lambda表达式创建命令对象，捕获接收者对象
    // 这比写一堆继承Command的类要方便太多了
    remote.setOnCommand([livingRoomLight]{ livingRoomLight->turnOn(); });
    remote.setOffCommand([livingRoomLight]{ livingRoomLight->turnOff(); });

    std::cout << "遥控器控制客厅灯：" << std::endl;
    remote.pressOnButton();
    remote.pressOffButton();

    // 切换到控制厨房灯，只需要重新设置命令
    remote.setOnCommand([kitchenLight]{ kitchenLight->turnOn(); });
    remote.setOffCommand([kitchenLight]{ kitchenLight->turnOff(); });

    std::cout << "\n遥控器控制厨房灯：" << std::endl;
    remote.pressOnButton();
    remote.pressOffButton();

    // 宏命令示例：组合多个命令
    std::vector<std::function<void()>> partyCommands;
    partyCommands.push_back([livingRoomLight]{ livingRoomLight->turnOn(); });
    partyCommands.push_back([kitchenLight]{ kitchenLight->turnOn(); });
    partyCommands.push_back([]{ std::cout << "Playing party music!" << std::endl; });

    // 一个宏命令，执行所有派对命令
    std::function<void()> partyOnMacro = [&partyCommands]{
        for (const auto& cmd : partyCommands) {
            cmd();
        }
    };

    std::cout << "\n执行派对宏命令：" << std::endl;
    partyOnMacro();

    return 0;
}

登录后复制

这段代码清楚地展示了如何用std::function作为命令的抽象接口，以及如何用Lambda表达式即时创建具体的命令实例。它极大地简化了传统命令模式中所需的类层次结构。

`std::function`在命令模式中扮演了什么角色，它比传统函数指针或多态有何优势？

std::function在命令模式里，简直就是那个“万能插座”，它能把各种各样的可调用对象——无论是普通函数、成员函数、函数对象，还是我们现代C++里最常用的Lambda表达式——都统一封装起来，提供一个统一的调用接口。对我来说，这解决了传统C++在处理回调或策略模式时，那种要么类型不兼容，要么需要大量虚函数继承的痛点。

它比传统函数指针的优势是显而易见的。函数指针类型是极其严格的，void(*)(int)就只能指向接受一个int参数、返回void的普通函数。它不能直接指向成员函数，也不能直接指向带有状态的函数对象。而std::function通过类型擦除（type erasure）技术，抹去了底层具体可调用对象的类型细节，只要它们的调用签名（参数和返回值）匹配，就能被std::function包装。这意味着你可以用一个std::function<void()>来存储一个Light对象的turnOn方法（通过lambda或std::bind绑定），也可以存储一个全局函数，甚至是一个自定义的、重载了operator()的类实例。这种灵活性，是函数指针望尘莫及的。

与传统的多态（抽象基类+虚函数）相比，std::function和Lambda的组合优势在于：

极大地减少了样板代码：你不再需要为每一个具体的命令都定义一个单独的类并继承自一个抽象基类。对于简单的命令，一个Lambda表达式就能搞定，代码量直线下降，可读性反而提升了。我个人非常喜欢这种“即用即抛”的命令创建方式，尤其是在需要大量细粒度命令的场景下。
更强的表达力与上下文捕获：Lambda表达式能够方便地捕获其定义时的上下文环境中的变量。这意味着你的命令可以直接访问和操作外部作用域的变量，而不需要通过构造函数传递。这在处理闭包（closure）风格的命令时特别有用，比如一个命令需要修改一个特定的外部计数器，或者操作一个特定的UI组件实例。
更灵活的组合：由于std::function可以包装任何可调用对象，你可以非常自然地将多个std::function组合成一个新的std::function，实现宏命令（Macro Command）或者命令链。例如，一个“派对模式”命令可以由“开客厅灯”、“开厨房灯”、“播放音乐”等多个子命令组合而成，每个子命令本身也是一个std::function。
更低的耦合：调用者（Invoker）完全不需要知道它持有的命令是哪个具体类的实例，它只知道这是一个std::function<void()>，可以被调用。这种程度的解耦，让系统更加健壮和易于维护。

当然，std::function并非没有代价，它通常会带来一些运行时开销（类似于虚函数调用），并且在某些极端性能敏感的场景下可能需要权衡。但对于大多数应用，它的便利性和灵活性带来的收益远超这点开销。

如何利用C++11及更高版本的Lambda表达式简化命令对象的创建？

Lambda表达式是C++11引入的语法糖，它允许你直接在代码中定义匿名函数对象。在命令模式中，Lambda简直是天作之合，它把创建命令对象的流程从“定义一个新类，实现接口，实例化”简化成了“一行代码搞定”。

具体来说，Lambda的语法是[捕获列表](参数列表){ 函数体 }。

捕获列表：这是Lambda的核心魅力之一，它决定了Lambda能访问哪些外部变量。你可以：
- []：不捕获任何外部变量。
- [var]：按值捕获var变量。Lambda内部会有一份var的拷贝。
- [&var]：按引用捕获var变量。Lambda内部直接引用外部的var，可以修改它。
- [=]：按值捕获所有外部作用域的局部变量。
- [&]：按引用捕获所有外部作用域的局部变量。
- [this]：按值捕获当前对象的this指针。
- [*this]：C++17特性，按值捕获当前对象本身。
- 混合捕获：[var1, &var2]，或者[=, &var2]（默认按值捕获，但var2按引用捕获）。
参数列表：命令模式中，如果你的命令不需要额外参数，通常就是空的，比如()。
函数体：这就是命令执行时真正要做的事情。

MacsMind
电商AI超级智能客服

131

查看详情

简化命令创建的例子：

假设我们有一个Heater类，有setTemperature(int temp)方法。

传统方式可能需要：

// 抽象命令接口
class Command { public: virtual void execute() = 0; };

// 具体命令类
class SetHeaterTemperatureCommand : public Command {
private:
    Heater* heater_;
    int temperature_;
public:
    SetHeaterTemperatureCommand(Heater* h, int temp) : heater_(h), temperature_(temp) {}
    void execute() override {
        heater_->setTemperature(temperature_);
    }
};

// 使用
Heater myHeater;
Command* cmd = new SetHeaterTemperatureCommand(&myHeater, 25);
cmd->execute();
delete cmd;

登录后复制

而使用Lambda和std::function，它变得如此简洁：

#include <functional> // for std::function
#include <iostream>

class Heater {
public:
    void setTemperature(int temp) {
        std::cout << "Heater temperature set to: " << temp << "°C" << std::endl;
    }
};

int main() {
    Heater myHeater;
    int targetTemp = 22; // 假设这是从某个UI控件获取的目标温度

    // 直接用Lambda创建命令，捕获myHeater和targetTemp
    std::function<void()> setTempCommand = [&myHeater, targetTemp]{
        myHeater.setTemperature(targetTemp);
    };

    setTempCommand(); // 执行命令

    // 如果要改变温度，可以轻松创建新的命令
    targetTemp = 28;
    std::function<void()> setHighTempCommand = [&myHeater, targetTemp]{
        myHeater.setTemperature(targetTemp);
    };
    setHighTempCommand();
    return 0;
}

登录后复制

看到了吗？没有额外的类定义，所有逻辑都在创建命令的那一刻内联完成。这不仅减少了文件数量和代码行数，更重要的是，它让代码意图变得非常清晰——这个Lambda就是执行setTemperature这个动作的命令。

捕获的注意事项：

在使用Lambda时，最容易犯的错误就是捕获策略的选择。如果按引用捕获了一个局部变量（[&var]），而这个Lambda被存储起来，在局部变量生命周期结束后才被调用，那么就会导致悬空引用（dangling reference），程序崩溃或者行为未定义。

例如：

std::function<void()> createCommand() {
    int value = 10;
    // 错误：按引用捕获局部变量value，当createCommand返回后，value将失效
    return [&value]{ std::cout << "Value: " << value << std::endl; };
}

int main() {
    auto cmd = createCommand();
    // 此时value已经不存在了，调用cmd()是未定义行为
    // cmd();
    return 0;
}

登录后复制

正确的做法是按值捕获（[value]），或者如果捕获的是动态分配的对象，使用智能指针（[ptr_to_obj]，其中ptr_to_obj是std::shared_ptr或std::unique_ptr）来管理生命周期。

std::function<void()> createSafeCommand() {
    int value = 10;
    // 正确：按值捕获局部变量value
    return [value]{ std::cout << "Value: " << value << std::endl; };
}

int main() {
    auto cmd = createSafeCommand();
    cmd(); // 安全调用
    return 0;
}

登录后复制

在实际项目中，我倾向于对所有需要捕获的指针或引用都进行仔细的生命周期分析，或者尽可能使用智能指针来规避这种风险。

除了基本的命令执行，这种现代方法如何支持撤销（Undo）和重做（Redo）操作？

撤销和重做是命令模式最强大的应用之一，它要求每个命令不仅能执行，还能“反向执行”。在传统命令模式中，这意味着你的Command接口会多一个virtual void undo() = 0;方法。那么，用std::function和Lambda怎么实现呢？

核心思想是，一个可撤销的命令不再只是一个std::function<void()>，而是一个包含两个std::function<void()>的结构：一个用于执行（execute），另一个用于撤销（undo）。

我们可以定义一个简单的结构体来封装这两个操作：

#include <iostream>
#include <vector>
#include <functional>
#include <memory>
#include <stack> // 用于存储历史命令

// 接收者 (Receiver)
class Document {
private:
    std::string content_;
public:
    Document(const std::string& initial_content = "") : content_(initial_content) {
        std::cout << "Document created with content: '" << content_ << "'" << std::endl;
    }
    void append(const std::string& text) {
        std::cout << "Appending: '" << text << "'" << std::endl;
        content_ += text;
        std::cout << "Current content: '" << content_ << "'" << std::endl;
    }
    void removeLast(size_t count) {
        if (content_.length() >= count) {
            std::cout << "Removing last " << count << " chars." << std::endl;
            content_.resize(content_.length() - count);
            std::cout << "Current content: '" << content_ << "'" << std::endl;
        } else {
            std::cout << "Cannot remove " << count << " chars, content too short." << std::endl;
        }
    }
    std::string getContent() const { return content_; }
};

// 可撤销命令的结构体
struct UndoableCommand {
    std::function<void()> execute_func;
    std::function<void()> undo_func;
};

// 命令管理器 (Invoker with Undo/Redo capabilities)
class CommandHistory {
private:
    std::stack<UndoableCommand> history_stack_;
    std::stack<UndoableCommand> redo_stack_; // 用于存储撤销后的命令，以便重做

public:
    void executeCommand(UndoableCommand cmd) {
        cmd.execute_func();
        history_stack_.push(std::move(cmd));
        // 每执行一个新命令，重做栈清空
        while (!redo_stack_.empty()) {
            redo_stack_.pop();
        }
    }

    void undo() {
        if (!history_stack_.empty()) {
            UndoableCommand cmd = history_stack_.top();
            history_stack_.pop();
            cmd.undo_func(); // 执行撤销操作
            redo_stack_.push(std::move(cmd));
            std::cout << "--- Undo executed ---" << std::endl;
        } else {
            std::cout << "Nothing to undo." << std::endl;
        }
    }

    void redo() {
        if (!redo_stack_.empty()) {
            UndoableCommand cmd = redo_stack_.top();
            redo_stack_.pop();
            cmd.execute_func(); // 重新执行操作
            history_stack_.

登录后复制

以上就是如何实现C++中的命令模式函数对象与std::function的现代替代的详细内容，更多请关注php中文网其它相关文章！