C++11 之 lambda函数的详细使用

桃扇骨 2023-07-18 12:59 5阅读 0赞

## 1. lambda 函数概述 ##

lambda 表达式是一种匿名函数，即没有函数名的函数；该匿名函数是由数学中的λ演算而来的。通常情况下，lambda函数的语法定义为：

**\[capture\] (parameters) mutable ->return-type \{statement\}**

其中：  
**\[capture\] ：**捕捉列表。捕捉列表总是作为lambda的开始，即出现于lambda的开始处。它是lambda的引出符（即开始标志）。编译器可以根据该“标志”来作出判断出该函数是否为lambda函数。同时“捕捉列表”能够捕捉上下文中的变量以作为lambda函数使用。  
**(parameters)：**参数列表。和C/C++中的普通函数参数意义一样。该部分是可选的，意味着如果我们不需要进行参数传递时，可以连同括号“（）”一起省略掉。  
**mutable：**该关键字为一个修饰符。在默认的情况下，lambda函数总是返回一个const，而当我们在参数列表后面注明了“mutable”关键字之后，则可以取消其常量性质。若在lambda中使用了mutable修饰符，则“参数列表”是不可省略掉的（即使是参数为空）。  
**->return-type：** 函数的返回值类型。和C/C++中的普通函数返回值类型的性质一样。主要目的是用来追踪lambda函数（有返回值情况下）的返回类型。若lambda函数不需要返回值，则可以直接将这部分省略掉。  
**\{statement\}：**函数体。在该函数体中，除了可以使用参数列表中的变量外，还可以使用所有捕获到的变量（即\[capture\] 中的变量）。

见下图：

### ![70][]   1.1. lambda 函数中“捕捉列表”详解 ###

C++11中的lambda函数，其中的“捕捉列表”是由0个或多个“捕捉项”组成，并以逗号“，”分隔。捕捉列表有如下几种形式：

**（1）\[var\] 表示值传递方式捕捉变量var。**

#include <iostream>
    #include <string>
    #include <stdio.h>
    using namespace std;
    int main()
    {
       int a = 1,b =2, c =3;
       auto retVal = [=,&a,&b]()
       {
           printf("inner c[%d]\n",c);
           a = 10;
           b = 20;
           return a+b;
       };
    
       printf("sum[%d]\n",retVal());
       printf("a[%d] b[%d] c[%d]\n",a,b,c);
       return 0;
    }

打印结果：  
inner c\[3\]  
sum\[30\]  
a\[10\] b\[20\] c\[3\]  
  
上面的代码中，“捕捉列表”由3项组成。以引用传递的方式捕捉变量a、b，以值传递的方式捕捉变量c。因此在lambda表达式的函数体中修改了变量a和b之后，父作用域中的a、b值也改变。而即使是在lambda函数内部修改了变量c的值，父作用域中的c仍然不会受到影响，因为是值传递的方式。（需在参数列表后面加上 mutable 关键字（修饰符））。同时

#include <iostream>
    #include <string>
    #include <stdio.h>
    using namespace std;
    int main()
    {
       int a = 1,b =2, c =3;
       auto retVal = [=,&a,&b]() mutable->int
       {
           printf("inner c[%d]\n",c);
           a = 10;
           b = 20;
           c = 30;
           printf("inner c2[%d]\n",c);
           return a+b;
       };
    
       printf("sum[%d]\n",retVal());
       printf("a[%d] b[%d] c[%d]\n",a,b,c);
       return 0;
    }

打印结果：  
inner c\[3\]  
inner c2\[30\]  
sum\[30\]  
a\[10\] b\[20\] c\[3\]  
  
**（2）\[=\] 表示值传递方式捕捉所有父作用域的变量（包括this）。**  
**（3）\[&var\] 表示引用传递捕捉变量var。**  
**（4）\[&\] 表示引用传递捕捉所有父作用域的比哪里（2020-02-18 09:36:12 修改） 的变量（包括this）。**

#include <iostream>
    #include <string>
    #include <stdio.h>
    using namespace std;
    int main()
    {
       int a = 1,b =2, c =3;
       auto retVal = [&]() mutable->int
       {
           printf("inner a[%d] b[%d] c[%d]\n",a,b,c);
           a = 10;
           b = 20;
           c = 30;
           return a+b;
       };
    
       printf("sum[%d]\n",retVal());
       printf("a[%d] b[%d] c[%d]\n",a,b,c);
       return 0;
    }

打印结果：  
inner a\[1\] b\[2\] c\[3\]  
sum\[30\]  
a\[10\] b\[20\] c\[30\]  
  
**（5）\[this\] 表示值传递方式捕捉当前的this指针。**  
同理(2),(3),(5)可以参考上面的两个例子。

## 2. lambda 函数特点 ##

(1)在C++11中，lambda函数是inline（内联函数）。

## 3. lambda 函数使用 ##

**代码一**

#include <iostream>
    #include <string>
    #include <stdio.h>
    using namespace std;
    int main()
    {
       int a = 6;
       int b = 8;
       auto sum = [](int a,int b) ->int{return a + b;};
       printf("sum[%d]\n",sum(a,b));
       return 0;
    }

//打印结果：sum\[14\]  
  
在代码一中，定义了一个简单的lambda函数，该函数的函数列表能够接收两个int类型的数据，而且返回值为int类型。

注意：lambda函数中，参数列表和返回类型都是可选的部分，而且捕捉列表和函数也可以为空。因此，在某种情况下，C++11中的简略版本的lambda函数可以是这样的：

**// 完整语法**  
**\[ capture-list \] ( params ) mutable(optional) constexpr(optional)(c++17) exception attribute -> ret \{ body \}**

**// 可选的简化语法**  
**\[ capture-list \] ( params ) -> ret \{ body \}  
\[ capture-list \] ( params ) \{ body \}**   
  
最为简洁的版本如下

**\[ capture-list \] \{ body \}**

**测试代码二**

#include <iostream>
    #include <string>
    #include <stdio.h>
    #include <functional>
    using namespace std;
    
    //lambda 表达式的第一种用法
    void LambdaUseOne()
    {
    	int a = 1, b = 2, c = 3;
    	auto retVal = [=, &a, &b]()
    	{
    		printf("inner c[%d]\n", c);
    		a = 10;
    		b = 20;
    		return a + b;
    	};
    
    	printf("sum[%d]\n", retVal());     //类似于函数对象的调用
    	printf("a[%d] b[%d] c[%d]\n", a, b, c);
    }
    
    //lambda 表达式的第二种用法
    void LambadaUseTwo(int a,std::function<int __stdcall(const int&)> one)
    {
    	int result = one(a);    //通过函数参数传入lambda表达式（function类型）
    	cout << result << endl;
    }
    
    //lambda 表达式的第三种用法
    void LambdaUseThree()
    {
    	int a = 1, b = 2, c = 3;
    	[=, &a, &b]()
    	{
    		printf("inner c[%d]\n", c);
    		a = 10;
    		b = 20;
    		return a + b;
    	}();    //直接在函数题后添加括号() 表示直接调用
    
    }
    
    
    int main()
    {
    	//lambda 表达式的第一种用法
    	LambdaUseOne();
    
    	cout << endl;
    	//lambda 表达式的第二种用法
    	int b = 3;
    	LambadaUseTwo(2, [=](int a)->int
    	{
    		return a + b;
    	}
    	);
    
        //lambda 表达式的第三种用法
        LambdaUseThree();
    
    	system("pause");
    	return 0;
    }

[70]: /images/20230528/4085c69a8d344c5bbbda9eba55e31d89.png