C++ 中的 lambda 表达式和 std::bind

最新推荐文章于 2026-06-16 20:19:21 发布
原创 最新推荐文章于 2026-06-16 20:19:21 发布 · 655 阅读 · 14 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#c++ #开发语言

1.Lambda 表达式：提供简单的方式定义匿名函数对象

1.2函数语法

[capture_clause] (parameters) -> return_type {
    // 函数体
}

1.3函数参数分析

1.3.1 [capture_clause]: 定义了 lambda 表达式从其所在作用域中捕获哪些变量以及如何捕获（值捕获或引用捕获）

        值捕获：创建变量的副本。

                1.lambda内部使用的是外部变量的拷贝

                2.外部变量的修改不会影响lambda内部的副本

                3.lambda内部对副本的修改不会影响外部变量

        引用捕获：使用变量的引用

                1.lambda内部直接操作外部变量

 捕获情况

[]：不捕获任何变量。                        ​​​​​​​        ​​​​​​​        ​​​​​​​        ​​​​​​​        ​​​​​​​        ​​​​​​​        ​​​​​​​        ​​​​​​​        ​​​​​​​        ​​​​​​​        ​​​​​​​        ​​​​​​​[=]：通过值捕获所有外部变量。

[&]：通过引用捕获所有外部变量。​​​​​​​​​​​​​​        ​​​​​​​        ​​​​​​​        ​​​​​​​        ​​​​​​​        ​​​​​​​        ​​​​​​​        ​​​​​​​        ​​​​​​​        ​​​​​​​            

[x, &y]：通过值捕获 x，通过引用捕获 y。

[=, &z]：通过值捕获所有外部变量，但通过引用捕获 z。​​​​​​​ ​​​​​​​        ​​​​​​​        ​​​​​​​        ​​​​​​​        ​​​​​​​        ​​​​​​​ 

[&, a]：通过引用捕获所有外部变量，但通过值捕获 a。

[this]：捕获所在的类对象的 this 指针，从而可以访问类成员。

1.3.2  (parameters): 和普通函数的参数列表一样（可选）

1.3.3  -> return_type: 可以省略，编译器会自动推导（可选）。但在某些复杂情况下需要显式指定。

// 完整语法
[capture] (parameters) -> return_type { body }

// 省略返回类型（编译器推导）
[capture] (parameters) { body }

// 省略参数（无参数）
[capture] { body }

// 省略捕获和参数（最简单的lambda）
[] { std::cout << "Hello" << std::endl; }

        可省略情况：当 lambda 函数体只有一个 return 语句，或者所有返回路径返回相同类型时，编译器可以自动推导返回类型

        

#include <iostream>

int main() {
    // 情况1：单一return语句 - 可以省略
    auto lambda1 = [](int a, int b) { // 省略 -> int
        return a + b; // 编译器推导为 int
    };
    
    // 情况2：多个return，但类型相同 - 可以省略
    auto lambda2 = [](int x) { // 省略 -> int
        if (x > 0) {
            return x * 2;
        } else {
            return x * 3; // 都是 int 类型
        }
    };
    
    // 情况3：void 返回类型 - 可以省略
    auto lambda3 = [](const std::string& msg) { // 省略 -> void
        std::cout << msg << std::endl;
        // 没有return语句，推导为void
    };
    
    std::cout << lambda1(5, 3) << std::endl; // 输出: 8
    std::cout << lambda2(5) << std::endl;    // 输出: 10
    lambda3("Hello");                        // 输出: Hello
    
    return 0;
}

       

         不可省略情况：当编译器无法自动推导返回类型时，必须显式指定。

#include <iostream>
#include <vector>

int main() {
    // 情况1：多个return语句返回不同类型 - 必须显式指定
    // auto ambiguous_lambda = [](bool flag) {
    //     if (flag) {
    //         return 10;    // int
    //     } else {
    //         return 3.14;  // double → 错误！类型不一致
    //     }
    // };
    
    // 正确：显式指定返回类型为 double
    auto good_lambda1 = [](bool flag) -> double {
        if (flag) {
            return 10;    // int 转换为 double
        } else {
            return 3.14;  // double
        }
    };
    
    // 情况2：递归lambda - 必须显式指定
    // auto factorial = [](int n) {
    //     if (n <= 1) return 1;
    //     return n * factorial(n - 1); // 错误！编译器还不知道返回类型
    // };
    
    // 正确：使用 std::function 或显式指定类型
    auto factorial = [](int n) -> int {
        if (n <= 1) return 1;
        return n * factorial(n - 1); // 现在可以了
    };
    
    std::cout << good_lambda1(true) << std::endl;  // 输出: 10
    std::cout << factorial(5) << std::endl;        // 输出: 120
    
    return 0;
}

1.3.4   { }：和普通函数一样。

1.4  常用使用例子

与 STL 算法结合（最常用）

#include <iostream>
#include <vector>
#include <algorithm> // for std::for_each, std::sort, etc.

int main() {
    std::vector<int> numbers = {3, 1, 4, 1, 5, 9, 2, 6};

    // 1. 使用 lambda 进行排序（按降序）
    std::sort(numbers.begin(), numbers.end(), [](int a, int b) {
        return a > b; // 降序规则
    });

    // 2. 使用 lambda 打印每个元素（for_each）
    std::for_each(numbers.begin(), numbers.end(), [](int n) {
        std::cout << n << " ";
    });
    std::cout << std::endl;

    // 3. 使用 lambda 计算有多少个大于 5 的数（count_if）
    int count = std::count_if(numbers.begin(), numbers.end(), [](int n) {
        return n > 5;
    });
    std::cout << "Count of numbers > 5: " << count << std::endl;

    // 4. 使用 lambda 查找第一个偶数（find_if）
    auto it = std::find_if(numbers.begin(), numbers.end(), [](int n) {
        return n % 2 == 0;
    });
    if (it != numbers.end()) {
        std::cout << "First even number: " << *it << std::endl;
    }

    return 0;
}

捕获局部变量

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> scores = {85, 92, 78, 96, 88};
    int passing_score = 90;

    // 值捕获 passing_score
    auto it = std::find_if(scores.begin(), scores.end(),
                          [passing_score](int score) { // 将 passing_score 的值拷贝进来
                              return score >= passing_score;
                          });

    // 引用捕获，用于修改外部变量
    int count = 0;
    std::for_each(scores.begin(), scores.end(),
                 [&count](int score) { // 通过引用捕获 count，以便修改它
                     if (score > 90) count++;
                 });
    std::cout << "Number of scores above 90: " << count << std::endl;

    return 0;
}

在异步编程中的应用（如 std::thread, std::async）

#include <iostream>
#include <thread>
#include <future>

int main() {
    int x = 10;

    // 启动一个线程，lambda 捕获了 x 的引用
    std::thread t([&x]() {
        std::this_thread::sleep_for(std::chrono::seconds(1));
        x *= 2; // 在线程中修改 x
        std::cout << "In thread, x = " << x << std::endl;
    });

    std::cout << "In main, x = " << x << std::endl;
    t.join(); // 等待线程结束
    std::cout << "After thread, x = " << x << std::endl; // x 已被修改

    // 与 std::async 结合，进行异步计算
    auto future = std::async(std::launch::async, [](int a, int b) {
        return a + b;
    }, 20, 30); // 参数 20 和 30 传递给 lambda

    int result = future.get(); // 获取异步结果
    std::cout << "Async result: " << result << std::endl;

    return 0;
}

作为回调函数

#include <iostream>
#include <functional>

// 一个模拟的按钮类
class Button {
public:
    // 设置点击事件回调函数
    void setOnClick(const std::function<void()>& callback) {
        onClick_ = callback;
    }

    void click() {
        if (onClick_) {
            onClick_();
        }
    }

private:
    std::function<void()> onClick_;
};

int main() {
    Button btn;
    std::string message = "Button clicked!";

    // 设置 lambda 作为回调，捕获了 message
    btn.setOnClick([&message]() {
        std::cout << message << std::endl;
    });

    // 模拟点击事件
    btn.click();

    return 0;
}

2.std::bind：将可调用对象（函数，函数指针，成员函数，lambda等）与其它参数进行绑定，生成一个新的可调用对象。

1.头文件和语法

#include <functional> // 必须包含这个头文件

auto new_callable = std::bind(existing_callable, arg_list);

2。函数参数

existing_callable：现有的可调用对象。

arg_list：参数列表。可以是占位符（如 std::placeholders::_1, _2, ...），也可以是具体的值

3.举例

绑定普通函数，并固定部分参数

#include <iostream>
#include <functional>

// 一个普通函数
void print_sum(int a, int b, int c) {
    std::cout << a << " + " << b << " + " << c << " = " << (a + b + c) << std::endl;
}

int main() {
    // 将 print_sum 的第三个参数固定为 100
    // _1 和 _2 是占位符，表示新可调用对象的第一和第二个参数
    auto bind_func1 = std::bind(print_sum, std::placeholders::_1, std::placeholders::_2, 100);

    // 调用 bind_func1(10, 20) 相当于调用 print_sum(10, 20, 100)
    bind_func1(10, 20);

    // 也可以重新排列参数顺序
    // 绑定为：第一个参数固定为 1，第二个参数是调用时的第一个参数，第三个参数是调用时的第二个参数
    auto bind_func2 = std::bind(print_sum, 1, std::placeholders::_2, std::placeholders::_1);
    // 调用 bind_func2(200, 300) 相当于调用 print_sum(1, 300, 200)
    bind_func2(200, 300);

    return 0;
}

绑定成员函数（非常重要）

成员函数有一个隐式的 this 指针作为第一个参数。

#include <iostream>
#include <functional>

class Calculator {
public:
    int multiply(int a, int b) {
        std::cout << "Calculating... ";
        return a * b;
    }
};

int main() {
    Calculator calc;

    // 绑定成员函数
    // 第一个参数必须是该类的对象（或指针/引用）
    // 方式1：使用对象
    auto bound_member = std::bind(&Calculator::multiply, calc, // 传入对象，会拷贝一份
                                  std::placeholders::_1,
                                  std::placeholders::_2);
    std::cout << bound_member(5, 6) << std::endl;

    // 方式2：使用对象引用（更常用，避免不必要的拷贝）
    auto bound_member_ref = std::bind(&Calculator::multiply, &calc, // 传入对象指针
                                      std::placeholders::_1,
                                      std::placeholders::_2);
    std::cout << bound_member_ref(7, 8) << std::endl;

    // 方式3：固定部分参数
    auto bound_member_fixed = std::bind(&Calculator::multiply, &calc,
                                        10, // 固定第一个参数为 10
                                        std::placeholders::_1); // 调用时只提供一个参数
    std::cout << bound_member_fixed(5) << std::endl; // 相当于 calc.multiply(10, 5)

    return 0;
}

绑定 lambda 表达式

既然 std::bind 接受任何可调用对象，自然也可以绑定 lambda。

#include <iostream>
#include <functional>

int main() {
    auto my_lambda = [](int a, const std::string& b, double c) {
        std::cout << a << ", " << b << ", " << c << std::endl;
    };

    // 绑定 lambda，并固定第二个和第三个参数
    auto bound_lambda = std::bind(my_lambda,
                                  std::placeholders::_1, // 新调用对象的第一个参数对应 lambda 的第一个参数
                                  "Hello",              // 固定 lambda 的第二个参数
                                  3.14);               // 固定 lambda 的第三个参数

    // 调用 bound_lambda(100) 相当于调用 my_lambda(100, "Hello", 3.14)
    bound_lambda(100);

    return 0;
}

pgk411
关注
C++11中lambda、std::function和std:bind详解
08-31
大家都知道C++11中增加了许多的新特性，下面在这篇文中我们就来聊一下lambda表达式，闭包，std::function以及std::bind。文中介绍的很详细，相信对大家具有一定的参考价值，有需要的朋友们下面来一起看看吧。
C++开发基础——lambda表达式与std::bind闭包
程序员与背包客_CoderZ
03-25 1059
C++语法基础
std::bind与lambda表达式
alexhu2010q的博客
07-19 1805
bind-vs-lambda 参考：bind-vs-lambda 参考：why-use-stdbind-over-lambdas-in-c14 参考：Lambdas vs. std::bind in C++11 and C++14 背景介绍 In C++98, such binding was accomplished via std::bind1st and std::bind2nd. TR1 added std::tr1::bind, which was promoted to std::bind
C++11 - std::bind简要介绍以及可绑定函数的几种形式总结
HW140701的博客
09-24 8274
1 std::bind template <class Fn, class... Args> /* unspecified */ bind (Fn&& fn, Args&&... args); template <class Ret, class Fn, class... Args> /* unspecified */ bind (Fn&& fn, Args&&... args); 1.1 函数模板说明 基于参数f
C++中函数对象模板function＜T＞、通用函数适配器std::bind和lambda
hanxiaoyong_的博客
01-27 1890
C++function用法、C++ std::bind用法、C++ lambda用法、using的使用、std::placeholders::_1用法
C++11 lambda表达式用法总结、std::function 、std::bind
灰太狼的小秘密
12-05 2898
一
C++编程进阶之std::bind与lambda表达式
01-09 1013
（function object），这个对象内部存储了绑定的函数和参数。当调用这个函数对象时，它会将绑定的参数和传入的参数组合起来，调用原始函数。（callable object），将函数的部分参数固定下来，生成一个新的函数对象，这个新的函数对象可以在后续调用时接收剩余的参数。的本质是创建一个可调用对象，将函数的部分参数固定下来，生成一个新的函数对象。要是追求极致的性能，尤其是在性能敏感、频繁调用的代码段，功能强大，但在现代 C++ 中，lambda 表达式通常是更好的替代方案。** 占位符的作用**
06 C++11 std::function、std::bind、lambda表达式
Snow__Sunny的博客
10-21 518
C++11 std:function std::bind lambda
C++之lambda函数与std::bind区别及用法实例(二百八十)
Android系统攻城狮
05-27 1173
本篇目的：C++之lambda函数与std::bind区别及用法实例C++11引入了lambda表达式，这是一种方便快捷的方式来创建匿名函数对象。Lambda函数在C++中非常有用，特别是在需要传递简短的函数作为算法的参数时，例如在std::sort或std::find_if等算法中。Lambda函数可以有参数，并且可以包含一个表达式或者一个花括号内的一系列语句。Lambda函数的基本语法如下：[捕获列表](参数列表) mutable -> 返回类型 {// 函数体。
Lambda表达式：代替std::bind的绝佳方法
尘中远的程序开发记录
04-18 7175
Lambda表达式：代替std::bind的绝佳方法 lambda表达式使得函数指针有了更灵活的使用方法，但是有些时候，对于大型的函数，还是不建议用lambda表达式，谁也不想在函数里又看到一段长长的函数。 Lambda表达式的用法在：C++11 lambda表达式在for_each和transform算法下的使用已经进行了介绍。另外我在另一篇文章利用C++11的function和bind功能
C++ 笔记 std::function bind 和 lambda表达式
flyconley的博客
03-01 919
lambda表达式 一个lambda表达式表示一个可调用的代码单元，我们可以将其理解为一个未命名的内联函数。与任何函数相似，一个lambda具有一个返回类型、一个参数列表、一个函数体。但与函数不同，lambda可以定义在函数内部，一个lambda表达式具有如下形式： [capture list捕获列表](parameter list参数列表) {函数体}，例子如下： auto f = ...
Ｃ++11 笔记 std::function，bind绑定器和lambda
花花邪思的博客
11-06 4388
Ｃ++11 笔记 std::function，bind绑定器和lambda背景c++将boost库中的function和bind在c++11中终于纳入了标准库的体系。 在传统的c++程序中，事件回调是通过虚函数进行的。在现代c++程序中，事件回调有了新的推荐做法，即std::funciton+std::bind,这种方式的一个明显优势是不必担心对象的生存期。 function模板类和bind模板函
C++11 特性--lambda、std::function和std::bind
xihuanzhi1854的博客
05-06 971
lambda -----------可调用对象包装器 std::function -----------可调用对象包装器 std::function是一个类模板，可以容纳除了类成员（函数）指针之外的所有可调用对象。 可调用对象有一下几种定义： 是一个函数指针，参考 C++ 函数指针和函数类型； 是一个具有operator()成员函数的类的对象； 可被转换成函数指针的类对象； 一个...
C++11：lambda表达式、bind函数、function类型
yvhqbat的博客
07-13 845
#include <iostream> #include <string> using namespace std; //lambda表达式：表示一个可调用单元，理解为一个未命名的内联函数。 //[capture list] (parameter list) -> return type { function body }void lambda_test() { //可以忽略参数列表和返回类
跟着做的C++20教程-实例33-Lambda的捕获子句(Capture Clause)
愚公
03-27 1080
目录实例概要实例代码实例结果实例解释实例扩展 实例概要 介绍lambda表达式中的捕获子句。 [](){}是Lambda表达式三个主要部分，其中[]为捕获子句（本实例要介绍的内容）；()是参数列表；{}函数体。 实例代码 int main(int argc, char** argv) { int a = 0; int b = 0; auto capturedByReferennce = [&]() {a = 3; b = 4; }; capturedByReferennce(); st
C++lambda表达式及bind函数总结
qq_39540537的博客
09-16 894
目录 引入lambda 值捕获 使用捕获列表 参数绑定 标准库bind函数 绑定check_size的sz参数 以下是对阅读<<C++Primer (第5版)>>lambda阅读部分总结 在实际的编程过程中,对于某些函数,我们希望对于传入的参数列表,其中某些参数是固定的值,而另外一个参数随着调用次数的增长而传入一个像STL容器一样的可迭代对象,对象的值随着*iterator值得不同而改变,每次调用该函数后会执行iterator++,并再次通过相同的传入参数调用该函数。
ITU-T G.1080 IPTV的体验质量(QoE)要求 (Quality of experience requirements for IPTV services)
雷霄骅(leixiaohua1020)的专栏
11-04 1442
IPTV的服务质量(QoE)要求 Quality of experience requirements for IPTV services Summary This Recommendation defines user requirements for Quality ofExperience for IPTV services. The QoE requirements are def...
Effective Modern C++ Item 34 优先选用lambda式，而非std::bind
鳴海步的博客
12-24 521
1. 先来点历史资料 std::bind是C++98中std::bind1st和std::bind2nd的后继特性，但是作为一种非标准特性而言，std::bind在2005年就已经是标准库的组成部分了。正是在那时，标准委员会接受了名称TR1的文档，里面就包含了std::bind的规格（在TR1中，bind位于不同的名字空间，所以是std::tr1::bind而非std::bind，还有一些借口细节与现在有所不同）。 2. 再来谈抛弃 这样的历史意味着，有些开发者已经有了十多年的std::bind开发经验。如
std::function和std::bind和lambda函数
weixin_53022668的博客
11-16 1106
C++中可调用对象的虽然都有一个比较统一的操作形式，但是定义方法五花八门。为程序功能实现提供多种可行方式时，也让可调用对象的统一管理变得麻烦。熟悉std::function,std::bind,lamdba函数这三把利器可以让你畅行接口世界。 std::function std::function 是一个可调用对象包装器，是一个类模板，可以容纳除了类成员函数指针之外的所有可调用对象，它可以用统一的方式处理函数、函数对象、函数指针，并允许保存和延迟它们的执行。 std::function 的实例能存储、复制及
分享如何实现Qt 高级开发 015：C++ 原生实现信号槽机制
最新发布
2401_85049165的博客
06-16 250
本文介绍了如何在C++中不依赖Qt框架原生实现信号槽机制。通过使用std::function和模板类，作者构建了Signal类来处理信号连接、发射和断开操作，并支持普通函数和成员函数作为槽。文章还讨论了线程安全和性能优化方案，包括使用互斥锁保护共享资源。这种实现方式保持了信号槽松耦合的特性，同时避免了Qt依赖，为C++开发者提供了一种轻量级的事件驱动编程方案。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值