c++中lambda表达式用法

时间 2021-05-21

标签 python ios c++ 算法 shell 闭包函数 this spa 指针栏目 C&C++ 繁體版

原文原文链接

说明一下，我用的是gcc7.1.0编译器，标准库源代码也是这个版本的。

本篇文章讲解c++11中lambda表达式用法。python

初次接触lambda这个关键字，记得仍是在python里面，但其实，早在2011年c++11推出来的时候咱们c++就有了这个关键字啦。lambda表达式是C++11中引入的一项新技术，利用lambda表达式能够编写内嵌的匿名函数，用以替换独立函数或者函数对象，而且使代码更可读。ios

所谓函数对象，其实就是对operator()进行重载进而产生的一种行为，好比，咱们能够在类中，重载函数调用运算符(),此时类对象就能够直接相似函数同样，直接使用()来传递参数，这种行为就叫作函数对象，一样的，它也叫作仿函数。c++

若是从广义上说，lambda表达式产生的是也是一种函数对象，由于它也是直接使用()来传递参数进行调用的。算法

1 lambda表达式基本使用

lambda表达式基本语法以下：shell

[ 捕获 ] ( 形参 ) -> ret { 函数体 };

lambda表达式通常都是以方括号[]开头，有参数就使用()，无参就直接省略()便可，最后结束于{}，其中的ret表示返回类型。闭包

咱们先看一个简单的例子，定义一个能够输出字符串的lambda表达式，完整的代码以下：函数

#include <iostream>

int main()
{
    auto atLambda = [] {std::cout << "hello world" << std::endl;};
    atLambda();
    return 0;
}

上面定义了一个最简单的lambda表达式，没有参数。若是须要参数，那么就要像函数那样，放在圆括号里面，若是有返回值，返回类型则要放在->后面，也就是尾随返回类型，固然你也能够忽略返回类型，lambda会帮你自动推导出返回类型，下面看一个较为复杂的例子：this

#include <iostream>

int main()
{
    auto print = [](int s) {std::cout << "value is " << s << std::endl;};
    auto lambAdd = [](int a, int b) ->int { return a + b;};
    int iSum = lambAdd(10, 11);
    print(iSum);

    return 0;
}

lambAdd有两个入参a和b，而后它的返回类型是int，咱们能够试一下把->int去掉，结果是同样的。spa

2 lambda捕获块

2.1 捕获的简单使用

在第1节中，咱们展现了lambda的语法形式，后面的形参和函数体之类都好理解，那么方括号里面捕获是啥意思呢？指针

其实这里涉及到lambda表达式一个重要的概念，就是闭包。

这里咱们须要先对lambda表达式的实现原理作一下说明：当咱们定义一个lambda表达式后，编译器会自动生成一个匿名类，这个类里面会默认实现一个public类型的operator()函数，咱们称为闭包类型。那么在运行时，这个lambda表达式就会返回一个匿名的闭包实例，它是一个右值。

因此，咱们上面的lambda表达式的结果就是一个一个的闭包。闭包的一个强大之处是能够经过传值或者引用的方式捕获其封装做用域内的变量，前面的方括号就是用来定义捕获模式以及变量，因此咱们把方括号[]括起来的部分称为捕获块。

看这个例子：

#include <iostream>

int main()
{
    int x = 10;
    auto print = [](int s) {std::cout << "value is " << s << std::endl;};
    auto lambAdd = [x](int a) { return a + x;};
    auto lambAdd2 = [&x](int a, int b) { return a + b + x;};
    auto iSum = lambAdd(10);
    auto iSum2 = lambAdd2(10, 11);
    print(iSum);
    print(iSum2);

    return 0;
}

当lambda块为空时，表示没有捕获任何变量，不为空时，好比上面的lambAdd是以复制的形式捕获变量x，而lambAdd2是以引用的方式捕获x。那么这个复制或者引用究竟是怎么体现的呢，咱们使用gdb看一下lambAdd和lambAdd2的具体类型，以下：

(gdb) ptype lambAdd
type = struct <lambda(int)> {
    int __x;
}
(gdb) ptype lambAdd2
type = struct <lambda(int, int)> {
    int &__x;
}
(gdb)

前面咱们说过lambda其实是一个类，这里获得了证实，在c++中struct和class除了有少量区别，其余都是同样的，因此咱们能够看到复制形式捕获其实是一个包含int类型成员变量的struct，引用形式捕获其实是一个包含int&类型成员变量的struct，而后在运行的时候，会使用咱们捕获的数据来初始化成员变量。

既然有初始化，那么必然有构造函数啊，而后捕获生成的成员变量，有operator()函数，暂时来说，一个比较立体的闭包类型就存在于咱们脑海中啦，对于lambda表达式类型具体组成，咱们暂时放一放，接着说捕获。

2.2 捕获的类型

捕获的方式能够是引用也能够是复制，可是到底有哪些类型的捕获呢？

捕获类型以下：

[]：默认不捕获任何变量；
[=]：默认以复制捕获全部变量；
[&]：默认以引用捕获全部变量；
[x]：仅以复制捕获x，其它变量不捕获；
[x...]：以包展开方式复制捕获参数包变量；
[&x]：仅以引用捕获x，其它变量不捕获；
[&x...]：以包展开方式引用捕获参数包变量；
[=, &x]：默认以复制捕获全部变量，可是x是例外，经过引用捕获；
[&, x]：默认以引用捕获全部变量，可是x是例外，经过复制捕获；
[this]：经过引用捕获当前对象（实际上是复制指针）；
[*this]：经过复制方式捕获当前对象；

能够看到，lambda是能够有多个捕获的，每一个捕获之间以逗号分隔，另外呢，无论多少种捕获类型，万变不离其宗，要么以复制方式捕获，要么以引用方式捕获。

那么复制捕获和引用捕获到底有什么区别呢？

标准c++规定，默认状况下，在lambda表达式中，对于operator()的重载是const属性的，也就意味着若是以复制形式捕获的变量，是不容许修改的，看这段代码：

#include <iostream>

int main()
{
    int x = 10;
    int y = 20;
    auto print = [](int s) {std::cout << "value is " << s << std::endl;};
    auto lambAdd = [x](int a) { 
    //    x++;  此处x是只读，不容许自增，编译会报错
        return a + x;
    };
    auto lambAdd2 = [&x](int a, int b) { 
        x = x+5;
        return a + b + x;
    };
    auto iSum = lambAdd(10);
    auto iSum2 = lambAdd2(10, 11);
    print(iSum);
    print(iSum2);

    return 0;
}

从代码能够看出，复制捕获不容许修改变量值，而引用捕获则容许修改变量值，为何呢，这里我理解，&x其实是一个int*类型的指针，因此咱们能够修改x的值，由于咱们只是对这个指针所指向的内容进行修改，并无对指针自己进行修改，且与咱们常规声明的引用类型入参同样，修改的值在lambda表达式外也是有效的。

那么若是我想使用复制捕获，又想修改变量的值呢，这时咱们就想起来有个关键字，叫作mutable，它容许在常成员函数中修改为员变量的值，因此咱们能够给lambda表达式指定mutable关键字，以下：

#include <iostream>

int main()
{
    int x = 10;
    int y = 20;
    auto print = [](int s) {std::cout << "value is " << s << std::endl;};
    auto lambAdd = [x](int a) mutable { 
        x++;
        return a + x;
    };
    auto iSum = lambAdd(10);
    print(iSum);
    print(x);

    return 0;
}

执行结果以下：

value is 21
value is 10

因此加上mutable之后就能够对复制捕获进行修改，但有一点，它的修改出了lambda表达式之后就无效了。

2.3 包展开方式捕获

仔细看2.2节中捕获类型，会发现有[x...]这样的类型，它其实是以复制方式捕获了一个可变参数，在c++中其实涉及到了模板形参包，也就是变参模板，看下面例子：

#include <iostream>

void tprintf()
{
    return;
}

template<typename U, typename ...Ts>
void tprintf(U u, Ts... ts)
{
    auto t = [ts...]{
        tprintf(ts...);
    };
    std::cout << "value is " << u << std::endl;
    t();
    return;
}

int main()
{
    tprintf(1,'c',3, 8);
    return 0;
}

它捕获了一组可变的参数，不过这里其实是为了演示对可变参数的捕获，强行使用了lambda表达式，不使用的话，代码可能更加简洁，咱们只须要经过这个演示知道怎么使用便可，另外对于变参模板的使用，这里就不展开来说了。

2.4 捕获的做用

我再看lambda的捕获的时候一直很奇怪，初看的话，这个捕获跟传参数有什么区别呢，都是把一个变量值传入lambda表达式体供使用，但仔细思考的话，它是有做用的，假设有这么一个案例，一个公司有999名员工，每一个员工的工号是从1~999，咱们如今想找出工号是8的整数倍的全部员工，一个可行的代码以下：

#include <iostream>
#include <array>

int main()
{
    int x = 8;
    auto t = [x](int i){
        if ( i % x == 0 )
        {
            std::cout << "value is " << i << std::endl;
        }
    };
    auto t2 = [](int i, int x){
        if ( i % x == 0 )
        {
            std::cout << "value is " << i << std::endl;
        }
    };
    for(int j = 1; j< 1000; j++)
    {
        t(j);
        t2(j, x);
    }
    return 0;
}

表达式t使用了捕获，而表达式t2没有使用捕获，从代码做用和量来看，它们其实区别不大，但有一点，对于表达式t，x的值只复制了一次，而对于t2表达式，每次调用都要生成一个临时变量来存放x的值，这实际上是多了时间和空间的开销，不过，对于这段代码而言，这点消耗能够忽略不计呢，但一旦数据上了规模，那就会有比较大的区别了。

对于捕获的做用，我暂时只想到了这一点，若是有大佬知道更多的做用，麻烦说一下呀。

对于捕获，仍是尽可能不要使用[=]或者[&]这样全捕获的形式，由于不可控，你不能确保哪些变量会被捕获，容易发生一些不测的行为。

3 lambda表达式做为回调函数

lambda表达式一个更重要的应用是它能够做为函数的参数传入，经过这种方式能够实现回调函数。好比在STL算法中，常常要给一些模板类或者模板函数来指定某个模板参数为lambda表达式，就想上一节说的，我想统计999个员工中工号是8的整数倍的员工个数，一个可用的代码以下：

#include <iostream>
#include <array>
#include <algorithm>

int main()
{
    int x = 8;
    std::array<int, 999> arr;
    for (int i =1; i< 1000; i++)
    {
        arr[i] = i;
    }
    int cnt = std::count_if(arr.begin(), arr.end(), [x](int a){ return a%x == 0;});
    std::cout << "cnt=" << cnt << std::endl;
    return 0;
}

这里很明显，咱们指定了一个lambda表达式来做为一个条件，更多时候，是使用排序函数的时候，指定排序准则，也可使用lambda表达式。

4 lambda表达式赋值

lambda表达式既然生成了一个类对象，那么它是否能够像普通类对象那样，进行赋值呢？

咱们写一段代码试一下：

#include <iostream>
using namespace std;

int main()
{
    auto a = [] { cout << "A" << endl; };
    auto b = [] { cout << "B" << endl; };
 
    //a = b; // 非法，lambda没法赋值
    auto c(a); // 合法，生成一个副本
    return 0;
}

很显然赋值不能够，而拷贝则能够，结合编译器自动生成构造函数规则，很明显，赋值函数被禁用了，而拷贝构造函数则没有被禁用，因此不能用一个lambda表达式给另一个赋值，但能够进行初始化拷贝。

5 总结

总而言之，根据lambda表达式的一个定义来看，它实际上是用于替代一些功能比较简单，但又有大量使用的函数，lambda在stl中大量使用，对于大部分STL算法而言，能够很是灵活地搭配lambda表达式来实现想要的效果。

同时这里要说明一下，lambda实际上是做为c++11新引入的一种语法规则，它与STL并无什么直接关联，只是STL里面大量使用了lambda表达式而已，并不能直接就说把它当作是STL的一部分。