C++精要分析lambda表达式的使用

引言

C++要走向现代语言，如果不支持lambda表达式，你很难认为这门语言和现代有什么关系。幸好，从C++11标准起，它就实现了对lambda表达式的支持。

那么，什么是lambda表达式呢？

lambda表达式是匿名函数，就是说不用定义函数名，函数实现可以直接嵌入在业务逻辑代码中。诸如python、java、C#等语言，都将其作为基础特性。

其优点是提高了代码的可读性，对于一些无需重用的方法特别适合。例如在容器的迭代中实现特定的查询逻辑。

语法与示例

C++11标准中，对于lambada表达式的定义如下：

[captures] (params) specifiers exception -> ret {body}

• [captures] —— 捕获列表，它用于捕获当前函数作用域的零个或多个变量，变量之间用逗号分隔。
• {params} —— 可选参数列表，其语法与普通函数参数列表一致。如果不需要参数，则可以忽略此项。
• specifiers —— 可选限定符，可选值为mutable。其意义是可以在函数体内修改按值捕获的变量。
• exception —— 可选异常说明符，可以使用noexcept来指明lambda是否会抛出异常。
• ret —— 可选返回值类型，lambda使用返回类型后置的语法来表示返回类型。如果没有返回值 ，则可忽略此部分。如果不指定返回类型，则编译器会根据代码实现为函数推导一个返回类型。
• {body} —— 表达式的函数体，此部分与实现普通函数体一致。

从上面的定义可以看到，lambda表达式的语法多少有些与我们以往的认知不太一样。所以，我们直接上代码来体会吧。

#include <iostream>
int main() {
    int x = 10;
    auto foo = [x](int y)->int { return x + y; };
    std::cout << foo(7) << std::endl;
}

各位不要手懒，务必打开IDE将这段代码运行一下，看看结果。然后再尝试修改一下参数类型，或者返回类型。

增加mutable之后，对x变量进行修改，看看会发生什么？

int main() {
    int x = 10;
    auto foo = [x](int y) mutable ->int { x++; return x + y; };
    std::cout << foo(7) << std::endl;
    std::cout << foo(7) << std::endl;
    std::cout << foo(7) << std::endl;
}

而一个最简形式的lambda表达式，可以是 auto foo = [] { return 0; };。

所以大家以后看到类似语法，可不要大惊小怪了，还以为这是什么另类的数组访问方式，或者琢磨->这个指针指向了个什么东西。

捕获列表

毫无疑问，lambda表达式中，最反直觉的就是捕获列表的定义。毕竟在我们的认知里，中括号是用来定义数组并访问数组元素的。

而且捕获列表的诸多特性，也是面试中挖坑的好地方。我们先从作用域开始说起。

关于lambda表达式的作用域，有四个重点：

• 第一，捕获列表的变量有两个作用域，一是lambda定义的函数作用域，二是表达式函数体所在代码的作用域；
• 第二，在表达式函数体内，默认情况下，被捕获变量是只读属性。如需修改，则要添加mutable标识；
• 第三，在表达式函数体内，修改被捕获变量的值，不影响原始变量的值；
• 第四，被捕获变量必须是非静态局部变量。

好，为了加强印象，我们先从面试挖坑场景开始。请先看第一坑：

int main() {
    int x = 10;
    auto foo = [x](int y) ->int { x++; return x + y; };
    std::cout << foo(8) << std::endl;
}

问：上述代码能通过编译吗？如果不能，是为什么？

答：不能。因为根据规则一和二，在表达式函数体内，x变量是只读，不能被修改。

好，上面的只是开胃菜，诡异的第二坑来了：

int main() {
    int x = 10;
    auto foo = [x](int y) mutable ->int {
        x++;
        std::cout << x << std::endl;
        return x + y;
    };
    foo(8);
    foo(8);
    std::cout << x << std::endl;
}

问：在上述代码执行完后，请说出所有std::cout语句输出什么内容？

答：根据规则三，分别输出11，12，10。

所以大家可以看到，前两次输出是在表达式体内对x值进行修改，x的状态是保留的了。但在函数体外，x变量的值仍然保持不变。千万要记住这个规则，这就是存在两个作用域所得到的结果。

后面我们会讲解其实现原理，这样就可以方便记忆这条规则了。

再来第三坑：

int y = 100;
int main() {
    static int x = 10;
    auto foo = [x, y](int z) ->int { return x + y + z; };
    std::cout << foo(8) << std::endl;
}

问：上述代码有什么问题，应该如何调整？

答：根据作用域规则四，x与y都不能作为lambda表达式的捕获列表变量。在表达式函数体内可以直接使用静态或者全局变量，所以只要修改为auto foo = [](int z) ->int { return x + y + z; };即可。

虽然上面这段代码放在gcc编译器下不会报错，只是出警告：capture of variable ‘x’ with non-automatic storage duration。但编译器实际上是作了一次选择，即认为你的意图是作为全局或静态变量来使用。可如果你只是手误或者忘了要调整代码，那就会出现预料之外的运行结果。

实际上，笔者所在公司就严格要求不能出现编译警告，这对于防止运行期出现偏差是非常重要的。

捕获引用

上一节我们所讲的，都是捕获值的用法。那么想将变量作为引用传递进lambda表达式，是否可以呢？

答案是肯定的，示例如下：

int main() {
    int x = 10;
    int y = 11;
    auto foo = [&x, &y](int z) mutable ->int {
        x++;
        y++;
        return x + y + z;
    };
    std::cout << foo(8) << std::endl;
    std::cout << x << std::endl;
    std::cout << y << std::endl;
}

可以看到，捕获引用就是在变量前加上&符号即可。切记不要与取地址相混淆。被引用变量在函数体内修改，也会影响函数体外同名变量的值，这一点与我们以往的认知相同。

至于上述代码结果，请各位先在脑海里执行一遍，然后上机验证。

特殊用法

捕获列表支持三种特殊情况，下面分别说明：

• [this] —— 捕获this指针，可以在类内的lambda表达式函数体内使用，以访问成员变量和方法；
• [=] —— 捕获当前作用域内全部变量的值，包括this。当变量较多时，可使用此符号；
• [&] —— 捕获当前作用域内所有变量的引用，包括this。

先看[this]的示例：

class CaptureOne {
    public:
        void test() {
            auto foo = [this] { std::cout << x << std::endl; };
            foo();
        }
    private:
        int x = 100;
};
int main() {
    CaptureOne one;
    one.test();
}

建议大家在上面这个例子里继续扩展，例如增加一个类方法，看看在表达式函数中如何调用，以及执行结果是什么。

再看[=]的示例：

int main() {
    int x = 10;
    int y = 11;
    int z = 12;
    auto foo = [=]() mutable ->int {
        x++;
        y++;
        return x + y + z;
    };
    std::cout << foo() << std::endl;
    std::cout << x << std::endl;
    std::cout << y << std::endl;
}

可以看到，这的确是方便了代码书写。如果表达式函数体内的变量增加或减少，都不必再费心思去调整捕获列表了。

另外，不知道大家还注意到一个细节没有，就是当参数列表为空时，如果存在mutable标识，则()是不能省略的。

最后，[&]还是烦请各位自己去实践并体验。

实现原理

C++多年老手，在上手lambda表达式的时候，应该会马上在脑海里跟函数对象关联起来。

我们先从定义一个函数类开始说起。所谓函数类，就是定义一个类，然后重载operator ()。这样可以将类对象作为函数一样来调用。

示例如下：

class FuncOne {
    public:
        FuncOne(int x, int y) : valx(x), valy(y){}
        int operator () () {
            return valx + valy;
        }
    private:
        int valx;
        int valy;
};
int main() {
    FuncOne one(10, 20);
    std::cout << one() << std::endl;
}

上述代码就是函数类的定义与函数对象的使用方法。而C++11标准中的lambda表达式，其实就是在编译器在编译期生成一个闭包类（可以理解为类似于FuncOne的类），然后在运行时由这个闭包类生成一个对象，称之为闭包。

而闭包就是一个匿名的函数对象，它包含了定义时作用域的上下文。这样我们就会发现lambda表达式，其实就是C++11给我们提供的一个语法糖。

现在再回头去理解捕获列表的四条原则，是否有恍然大悟之感？理解了原理，对于原则就不用死记硬背了，祝各位面试好运！

应用

当然，我们不能满足于只过面试关，还应当在工作中用好它才行。做C++开发的，用好STL是基本功，而lambda表达式与STL相结合，可以简化代码，发挥出强大的威力来。

先看一个需求：我们要在一组vector列表中，打印可以整除4的数。

示例代码：

#include        <iostream>
#include        <vector>
#include        <algorithm>
int main() {
    std::vector<int> num_list = {1, 3, 9, 10, 12, 17, 18};
    std::cout << *std::find_if(num_list.cbegin(), num_list.cend(),
            [](int i) { return (i % 4) == 0;}) << std::endl;
}

大家可以看到，如果是在以前，要实现这个功能，需要额外写多少代码。

也希望各位能从这个简单示例开始，回头去梳理自己以前写的代码，可以怎样优化结构并提高效率。并且在将来的开发过程中，不断修炼功夫，成为C++大咖！