【C++】C++新增特性解析：Lambda表达式、包装器与绑定的应用

V可变参数模板与emplace系列

C++语法	相关知识点	可以通过点击	以下链接进行学习	一起加油！
命名空间	缺省参数与函数重载	C++相关特性	类和对象-上篇	类和对象-中篇
类和对象-下篇	日期类	C/C++内存管理	模板初阶	String使用
String模拟实现	Vector使用及其模拟实现	List使用及其模拟实现	容器适配器Stack与Queue	Priority Queue与仿函数
模板进阶-模板特化	面向对象三大特性-继承机制	面向对象三大特性-多态机制	STL 树形结构容器	二叉搜索树
AVL树	红黑树	红黑树封装map/set	哈希-开篇	闭散列-模拟实现哈希
哈希桶-模拟实现哈希	哈希表封装 unordered_map 和 unordered_set	C++11 新特性：序章	右值引用、移动语义、万能引用实现完美转发	可变参数模板与emplace系列

大家好，我是店小二。在这篇文章中，我们将深入探讨C++11的新特性——Lambda表达式、包装器与绑定的应用。如果在阅读过程中有不清楚的地方或发现任何错误，欢迎随时私信交流探讨。

?个人主页：是店小二呀
?C语言专栏：C语言
?C++专栏： C++
?初阶数据结构专栏： 初阶数据结构
?高阶数据结构专栏： 高阶数据结构
?Linux专栏： Linux

?喜欢的诗句:无人扶我青云志 我自踏雪至山巅

文章目录

一、lambda表达式1.1 lambda表达式说明1.2 可省略部分1.3 lambda使用场景(个人推荐使用第二种)1.4 比较lambda和仿函数1.5 lambda类型1.5.1 未定义类型1.5.2 定义类型 1.6 捕获列表1.6.1 捕获列表说明1.6.2 什么情况下捕捉列表必须为空？1.6.3 传值捕捉1.6.4 mutable可以修改拷贝对象1.6.5 引用捕获1.6.6 传值捕捉所有对象1.6.7 传引用捕捉所有对象1.6.8 混合捕捉 1.7 函数对象与lambda表达式 二、包装器1.1 function包装器1.2 function使用场景(对上面的修改) 三、bind绑定3.1 bind概念3.2 placeholders

一、lambda表达式

在C++98中，如果想要对一个数据集合中的元素进行排序，可以使用std::sort方法 。

struct Goods{    string _name;    double _price;    int _evaluate;    Goods(const char* str, double price, int evaluate)        :_name(str)            ,_price(price)            ,_evaluate(evaluate)        {}};struct ComparePriceLess{    bool operator()(const Goods& gl, const Goods& gr)    {        return gl._price < gr._price;    }};struct ComparePriceGreater{    bool operator()(const Goods& gl, const Goods& gr)    {        return gl._price > gr._price;    }};int main(){    vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2,                                                           3 }, { "菠萝", 1.5, 4 } };    sort(v.begin(), v.end(), ComparePriceLess());    sort(v.begin(), v.end(), ComparePriceGreater());}

随着C++语法的发展，上面的写法过于复杂，每次为了实现一个algorithm算法，都要重新去写一个类，如果每次比较的逻辑不一样，还要去实现多个类，特别是相同类的命名，这些都给编程者带来了极大的不便。因此，在C++11语法中出现了Lambda表达式 (本质也是匿名对象调用仿函数)

1.1 lambda表达式说明

lambda表达式书写格式：[capture-list] (parameters) mutable -> return-type { statement }

lambda表达式各部分说明：

[capture-list] 捕捉列表：该列表总是出现在lambda函数的开始位置，编译器根据[]来判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda函数使用**(parameters)参数列表:**与普通函数的参数列表一致，如果不需要参数传递，则可以连同()一起省略mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性。使用该修饰符时，参数列表不可省略(即使参数为空) (这个一般可以省略)->returntype返回值类型:用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推导{statement}函数体:在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量。

1.2 可省略部分

在lambda函数定义中，参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为空。

因此C++11中最简单的lambda函数为：[]{}表示lambda函数不能做任何事情

lambda表达式实际上可以理解为无名函数，该函数无法直接被调用，如果想要直接调用，可借助auto将其赋值给一个变量。

int main(){//lambdaauto add1 = [](int a, int b)->int {return a + b; };//返回值 可以省略auto add2 = [](int a, int b) {return a + b; };//没有参数，参数列表可以省略auto func1 = [] {cout << "hello world" << endl; };    //调用lambda匿名函数cout << add1(1, 2) << endl;func1();return 0;}

1.3 lambda使用场景(个人推荐使用第二种)

//第一种auto ComparePriceGreater = [](const Goods& gl, const Goods& gr) { return gl._price > gr._price;});sort(v.begin(), v.end(),ComparePriceGreater);//第二种sort(v.begin(), v.end(), [](const Goods& gl, const Goods& gr)      {          return gl._price > gr._price;     });

1.4 比较lambda和仿函数

功能：仿函数和 Lambda 表达式都能重新定义函数调用的行为，但是 Lambda 表达式更加灵活和直观，特别是在需要定义简短、一次性的函数时非常方便。语法：Lambda 表达式的语法更为紧凑，使得代码更易于阅读和维护，而仿函数则更适合于需要长期保存状态或多次调用的情况。使用场景：在现代 C++ 中，Lambda 表达式通常更受欢迎，因为它们简洁明了，且能够直接在需要时定义和使用，避免了定义额外的类或结构体。

上述代码就是使用C++11中lambda表达式来解决，可以看出lambda表达式实际是一个匿名函数。既然是匿名函数lambda的类型也是不得而知的，但是我们可以通过cout << typeid().name << endl;参考下类型

1.5 lambda类型

Lambda 表达式在 C++ 中的类型可以有两种主要形式：*未命名类型和命名类型

1.5.1 未定义类型

当 Lambda 表达式没有被赋予一个变量或者没有作为参数传递给一个模板时，它们是未命名的，也就是没有特定的类型，对象的行为是函数体和函数参数决定的。未命名类型的 Lambda 表达式：auto lambda = [](int x){return x * 2;};

1.5.2 定义类型

当 Lambda 表达式被赋予一个变量或者被用作模板参数时，它们可以有一个具体的类型。命名类型的 Lambda 表达式:std::function<int(int)> lambda = [](int x) { return x * 2; };

lambda原理类似范围for。lambda编译时，编译器会生成对应仿函数的名称，对此lambda本质还是仿函数。

1.6 捕获列表

1.6.1 捕获列表说明

捕捉列表描述了上下文中那些数据可以被lambda使用，以及使用的方式传值还是传引用。:

[var]：表示值传递方式捕捉变量var[=]：表示值传递方式捕获所有父作用域中的变量(包括this)[&var]：表示引用传递捕捉变量var[&]：表示引用传递捕捉所有父作用域中的变量(包括this)[this]：表示值传递方式捕捉当前的this指针

捕获列表注意：

父作用域指包含lambda函数的语句块语法上捕捉列表可由多个捕捉项组成，并以逗号分割。比如：[=, &a, &b]：以引用传递的方式捕捉变量a和b，值传递方式捕捉其他所有变量[&，a, this]：值传递方式捕捉变量a和this，引用方式捕捉其他变量捕捉列表不允许变量重复传递，否则就会导致编译错误。比如：[=, a]：=已经以值传递方式捕捉了所有变量，捕捉a重复在块作用域以外的lambda函数捕捉列表必须为空。在块作用域中的lambda函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者非局部变量都会导致编译报错。lambda表达式之间不能相互赋值，即使看起来类型相同

1.6.2 什么情况下捕捉列表必须为空？

如果一个lambda函数被定义在某个块作用域内，而它试图在这个块作用域外部（即在这个块结束后）使用，这时这个lambda函数的捕捉列表必须为空。原因是：

捕捉的变量作用域有限：在块作用域结束后，块作用域内的局部变量将不再存在。如果lambda函数捕捉了这些变量，并在块外部被调用，这会导致未定义行为，因为那些变量已经销毁了。捕捉列表为空：意味着lambda函数不依赖于块作用域中的任何局部变量，这样lambda函数就可以在块作用域结束后安全地使用。

块作用域：这是一个局部作用域，通常指在花括号 {} 中的代码块，比如函数体或循环体。

以上是相关捕获列表的相关知识，以下将通过代码进行分析，深入理解使用。

1.6.3 传值捕捉

第一种:捕获a，b对象给lambda，但是不可以修改捕获对象，因为这里捕获a，b对象是对外面域a，b对象的拷贝，临时对象具有常性。

int main(){int a = 10, b = 20;cout << "a: " << a << "   " << "b: " << b << endl;auto swap = [a, b]() {int tmp = a;a = b;b = tmp;};swap();cout << "a: " << a << "   " << "b: " << b << endl;return 0;}

1.6.4 mutable可以修改拷贝对象

mutable可以修改传值捕捉对象(日常一般不需要)，因为这里捕获a，b对象是对外面域a，b对象的拷贝，虽然修改也不改变外面的a b。

int main(){int a = 10, b = 20;cout << "a: " << a << "   " << "b: " << b << endl;auto swap = [a, b]() mutable{int tmp = a;a = b;b = tmp;};swap();cout << "a: " << a << "   " << "b: " << b << endl;return 0;}

1.6.5 引用捕获

int main(){int a = 10, b = 20;cout << "a: " << a << "   " << "b: " << b << endl;auto swap = [&a,&b]() {int tmp = a;a = b;b = tmp;};swap();cout << "a: " << a << "   " << "b: " << b << endl;return 0;}

1.6.6 传值捕捉所有对象

int main(){    int a = 1, b = 2, c = 3, d = 4, e = 5;    // 传值捕捉所有对象    auto func1 = [=]()    {        return a + b + c * d;    };    cout << func1() << endl;    return 0;}

1.6.7 传引用捕捉所有对象

int main(){    int a = 1, b = 2, c = 3, d = 4, e = 5;    auto func = [&]()    {        a++;        b++;        c++;        d++;        e++;    };    func();    cout << a << b << c << d << e << endl;    return 0;}

1.6.8 混合捕捉

auto func3 = [&, d, e](){    a++;    b++;    c++;    d++;    e++;};func3();cout << a << b << c << d << e << endl;

以上虽然有什么传值捕获、引用捕获、混合捕获，其实只要调用函数传值感觉差不多，这里重点是掌握用法就行了。

1.7 函数对象与lambda表达式

函数对象又称为仿函数，即可以想函数一样使用的对象，就是在类中重载了operator()运算符的类对象。

class Rate{public:Rate(double rate) : _rate(rate){}double operator()(double money, int year){return money * _rate * year;}private:double _rate;};int main(){// 函数对象double rate = 0.49;Rate r1(rate);r1(10000, 2);// lamberauto r2 = [=](double monty, int year)->double {return monty * rate * year;};r2(10000, 2);return 0;}

从使用方式上来看，函数对象与lambda表达式完全一样，函数对象将rate作为其成员变量，在定义对象时给出初始值即可，lambda表达式通过捕获列表可以直接将该变量捕获到。

实际在底层编译器对于lambda表达式的处理方式，完全就是按照函数对象的方式处理的，即：如果定义了一个lambda表达式，编译器会自动生成一个类，在该类中重载了operator()

二、包装器

//可调用对象  -- 使用了模板template <class F, class T>    T useF(F f, T x){    static int count = 0;    cout << "count:" << ++count << endl;    cout << "count:" << &count << endl;    return f(x);};double f(double i){    return  i / 2;}struct Functor{    double operator()(double d)    {        return d / 3;    }};int main(){    //函数名    cout << useF(f, 11.11) << endl;    //函数对象(这里是匿名对象)    cout << useF(Functor(), 11.11) << endl;    //lambda表达式（利用模板）    cout << useF([](double d)->double {return d / 4; }, 11.11) << endl;    return 0;}

通过模板根据不同的类型可以调用不同的可调用对象，比如函数指针、仿函数对象、lambda，如此繁多的选择也可能会导致模板效率低下。通过上面的程序验证，这里useF函数模板实例化了三份，而且对于不同的可调用对象也有存在于自己的缺点和优点，这里就需要包装器进行统一下了。

可调用对象优缺点分析:

函数指针 --> 类型定义复杂仿函数对象 --> 要定义一个类，用的时候有点麻烦，不适合统一类型lambda --> 没有类型概念(类型对我们没有用)

1.1 function包装器

function包装器也叫作适配器。C++中的function本质是一个类模板，也是一个包装器。std::function在头文件。

function类模板原型

template <class T>  function; // undefindtemplate <class Ret, class... Args>class function<Ret(Args...)>;模板参数说明：    Ret : 被调用函数的返回类型    Args…：被调用函数的形参

function不是定义可调用对象，而是包装可调用对象

function<int(int,int)> fc1;      ↑      ↑      返回值类型  形参类型列表

1.2 function使用场景(对上面的修改)

#include <functional>template<class F, class T>    T useF(F f, T x){    static int count = 0;    cout << "count:" << ++count << endl;    cout << "count:" << &count << endl;    return f(x);}double f(double i){    return i / 2;}struct Functor{    double operator()(double d)    {        return d / 3;    }};int main(){    // 函数名    std::function<double(double)> func1 = f;    cout << useF(func1, 11.11) << endl;    // 函数对象    std::function<double(double)> func2 = Functor();    cout << useF(func2, 11.11) << endl;    // lamber表达式    std::function<double(double)> func3 = [](double d)->double { return d / 4; };    cout << useF(func3, 11.11) << endl;    return 0;}

通过以上代码，可以更好地去了解包装可调用对象，达到统一的作用。不妨在看一个场景。

主要是看红色框起来的地方跟左边代码对比，其实逻辑是大致相同，如果遇到操作符进行对应的运算，左边是通过switch分支语句实现，右边则是通过map的kv模型，将对于运算符(这里是字符)和包装器联系在一起，而包装器是对可调用对象进行包装，保证了不同的操作符对应不同仿函数的逻辑。然后下面返回仿函数直接调用就行了。将可调用函数跟数值联系起来并且存储在map类中。

三、bind绑定

3.1 bind概念

std::bind函数定义在头文件中，是一个函数模板，它就像一个函数包装器(适配器)，接受一个可调用对象（callable object），生成一个新的可调用对象来“适应”原对象的参数列表。

一般而言，我们用它可以把一个原本接收N个参数的函数fn，通过绑定一些参数，返回一个接收M个（M可以大于N，但这么做没什么意义）参数的新函数。同时，使用std::bind函数还可以实现参数顺序调整等操作。

// 原型如下：template <class Fn, class... Args>/* unspecified */ bind(Fn&& fn, Args&&... args);// with return type (2)template <class Ret, class Fn, class... Args>/* unspecified */ bind(Fn&& fn, Args&&... args);

可以将bind函数看作一个通用的函数适配器，它接受一个可调用对象，生成一个新的可调用对象来"适应"原对象的参数列表

调用bind的一般形式:auto newCallable ==bind(callable,arg_list)；

参数部分:

newCallable本身是一个可调用对象arg_list是一个逗号分隔的参数列表，对应给定的callable的参数

当我们调用newCallable时，neweCallable会调用callable，并传给它arg_list中的参数。

3.2 placeholders

arg_list中的参数可能包含形如_n的名字，其中n是一个整数，这些参数是"占位符"，表示newCallable的参数的"位置"。数值n表示n生成的可调用对象中参数的位置: _1未newCallable的第一个参数， _2为第二个参数。以此类推。

std::placeholders::_1、std::placeholders::_2 等是 C++11 标准引入的占位符，用于绑定函数对象时表示参数的位置。它们依次表示函数的第一个、第二个、第三个参数，以此类推。

std::bind 这里绑定了 fx 函数的第一个参数 s 为字符串 name（即“王昭君”），并将第二个参数和第三个参数的位置分别用 _1 和 _2 来占位。这意味着生成的 f 是一个新的可调用对象，它接受两个参数，分别用于 fx 的第二个参数 x 和第三个参数 y。

std::placeholders::_1 和 _2 指定了新函数对象 f 的参数传递到原函数 fx 的对应位置，分别表示第二个和第三个参数位置。

---

以上就是本篇文章的所有内容，在此感谢大家的观看！这里是店小二呀C++笔记，希望对你在学习C++语言旅途中有所帮助！