讲师中心 微信公众号

工具推荐

视频效率加速
剧云
剧云

中文短剧剧本制作平台

立刻MV
立刻MV

低成本歌曲 MV、视频生成

updream

一键生成高质量推广成片

Laper
Laper

剧本策划到成片协作

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

老晨酱_2023

老晨酱_2023

发布时间:2025-07-16 10:07:02

|

927人浏览过

|

来源于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的现代替代

解决方案

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

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

设想我们有一个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表达式即时创建具体的命令实例。它极大地简化了传统命令模式中所需的类层次结构。

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

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

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

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

与传统的多态(抽象基类+虚函数)相比,std::function和Lambda的组合优势在于:

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

    C++14
    C++14

    C++14 对 C++11 的修正与增强版本,适合旧系统维护和较老工具链兼容。

    下载
  • 函数体:这就是命令执行时真正要做的事情。

简化命令创建的例子:

假设我们有一个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></void>,而是一个包含两个std::function<void></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_.

热门AI工具

更多
WorkBuddy

一款AI办公效率工具,主要用于腾讯云推出的AI原生桌面智能体工作台,适合需要提升相关任务效率的用户。

豆包大模型

豆包大模型是一款由字节跳动推出的企业级大语言模型服务平台。

VibeKnow
VibeKnow Hot

一款AI视频创作工具,主要用于全球首个AI知识视频创作平台,文档、文章、网页,一键生成视频,适合需要提升相关任务效率的用户。

DeepSeek

DeepSeek是一款面向对话、写作、编程和推理场景的AI大模型工具。

超级简历WonderCV

一款AI办公效率工具,主要用于免费求职简历模版下载制作,应届生职场人必备简历制作神器,适合需要提升相关任务效率的用户。

Flowith
Flowith Hot

Flowith是一款基于画布和智能体工作流的 AI 协作工作空间。

小橡皮AI

一款AI工具,主要用于小橡皮一键去AI味,将机器味重的内容改得更有活人感,防止因为 AI 内容被平台打上 AI 标签,以及限流,适合需要提升相关任务效率的用户。

SoundView
SoundView Hot

SoundView是一款面向跨境电商的视频翻译、配音和本地化 AI 创作平台。

音述AI
音述AI Hot

一款AI音频处理工具,主要用于音述AI是一个以“用声音述说故事”为核心的 AI 音乐创作与声音分享社区,适合需要提升相关任务效率的用户。

相关专题

更多
java多态详细介绍
java多态详细介绍

本专题整合了java多态相关内容,阅读专题下面的文章了解更多详细内容。

375

2025.11.27

golang结构体相关大全
golang结构体相关大全

本专题整合了golang结构体相关大全,想了解更多内容,请阅读专题下面的文章。

5514

2025.06.09

golang结构体方法
golang结构体方法

本专题整合了golang结构体相关内容,请阅读专题下面的文章了解更多。

5671

2025.07.04

string转int
string转int

在编程中,我们经常会遇到需要将字符串(str)转换为整数(int)的情况。这可能是因为我们需要对字符串进行数值计算,或者需要将用户输入的字符串转换为整数进行处理。php中文网给大家带来了相关的教程以及文章,欢迎大家前来学习阅读。

7599

2023.08.02

int占多少字节
int占多少字节

int占4个字节,意味着一个int变量可以存储范围在-2,147,483,648到2,147,483,647之间的整数值,在某些情况下也可能是2个字节或8个字节,int是一种常用的数据类型,用于表示整数,需要根据具体情况选择合适的数据类型,以确保程序的正确性和性能。本专题为大家提供相关的文章、下载、课程内容,供大家免费下载体验。

3605

2024.08.29

c++怎么把double转成int
c++怎么把double转成int

本专题整合了 c++ double相关教程,阅读专题下面的文章了解更多详细内容。

4748

2025.08.29

C++中int的含义
C++中int的含义

本专题整合了C++中int相关内容,阅读专题下面的文章了解更多详细内容。

3165

2025.08.29

javascriptvoid(o)怎么解决
javascriptvoid(o)怎么解决

javascriptvoid(o)的解决办法:1、检查语法错误;2、确保正确的执行环境;3、检查其他代码的冲突;4、使用事件委托;5、使用其他绑定方式;6、检查外部资源等等。本专题为大家提供相关的文章、下载、课程内容,供大家免费下载体验。

636

2023.11.23

Go-Zero API开发使用教程
Go-Zero API开发使用教程

本专题聚焦Go-Zero的API开发,拆解.api描述文件的语法结构、路由与分组定义、参数绑定与校验规则,说明统一响应体、JWT鉴权、跨域与接口文档生成的落地方式,并给出网关聚合与接口测试的实践建议。

100

2026.11.12

热门下载

更多
网站特效
/
网站源码
/
网站素材
/
前端模板

精品课程

更多
相关推荐
/
热门推荐
/
最新课程
关于我们 免责申明 举报中心 意见反馈 讲师合作 广告合作 最新更新
php中文网:公益在线php培训,帮助PHP学习者快速成长!
关注服务号
PHP中文网订阅号
每天精选资源文章推送

Copyright 2014-2026 https://www.php.cn/ All Rights Reserved | php.cn