Lambda表达式概述

Lambda表达式是C++11中最重要的新特性之一，而Lambda表达式，实际上就是提供了一个类似于匿名函数（匿名函数实际上就是一个没有名字的函数）的特性，在多线程，并发中具有及其重要的作用。

Lambda表达式意义

使用匿名函数有一些什么好处呢？在我们使用某个函数时，可能这个函数我们只需要调用一次，只在当前的情况下会使用这个函数，在其他地方不会在复用了。这时候我们要是在专门写一个函数就不太划算，但是要是不写这个函数呢，我们的代码就会显得很紊乱，故为了针对这种情况我们就有了匿名函数。

1 Lambda表达式语法定义

[捕获列表]（参数列表）mutble（可选）异常属性->返回值{函数体}

1. 捕获列表：在C++规范中也称为Lambda导入器， 捕获列表总是出现在Lambda函数的开始处。实际上，[ ]是Lambda引出符。编译器根据该引出符判断接下来的代码是否是Lambda函数，捕获列表能够捕捉上下文中的变量以供Lambda函数使用。
2. 参数列表：与普通函数的参数列表一致，如果不需要参数传递，则可以连同括号“()”一起省略。
3. mutble（可变规则）:mutable修饰符， 默认情况下Lambda函数总是一个const函数，mutable可以取消其常量性。在使用该修饰符时，参数列表不可省略（即使参数为空）
4. 异常属性：用于Lamdba表达式内部函数抛出异常。
5. 返回值：与普通函数返回值一样，但是在有无返回值的情况下都可以省略让编译器对返回类型进行推导。
6. 函数体：内容与普通函数一样，不过除了可以使用参数之外，还可以使用所有捕获的变量。

//以下为Lambda表达式的标准形式 后面会逐一介绍每个参数的含义
int main()
{
    
	int c = [](int a, int b) -> int {
    
	return a + b; 
	}(10,20);
	cout<< c <<endl;
	return 0;
}

输出结果：30

2 Lambda参数详解

由于Lambda表达式与普通函数参数之间最大的区别在于Lambda表达式多了可变规则以及捕获列表，因此这里我主要对这两方面重点介绍，后续学习之中，如诺发现其他用法，后续进行补充。

2.1 捕获列表（Capture List）

2.1.1 捕获变量的形式

Lambde表达式与普通函数的区别除了Lambda没有函数名之外，还有一个最大的区别就是Lambda表达式的捕获列表，Lambda函数想要获取函数参数列表之外的变量，就必须通过参数列表来访问，捕获列表描述了上下文中哪些数据可以被Lambda使用。语法上，与函数传参类似，捕获列表传参也有两种方式，一种是按值捕获，一种是按引用捕获。在“[ ]”包括起来的是捕获列表，捕获列表由多个捕获项组成，并以逗号分隔。捕获列表有以下几种形式：

1. [ ]表示不捕获任何变量

int main()
{
    
	[]() -> int {
    
	count<<"Lambda表达式"<<endl; 
	}();//Lambda表达式后面加()表示直接调用
	return 0;
}

//输出结果：Lambda表达式

2. [var]按值捕获var变量

int main()
{
    
	int var = 10;
	[var]() -> void{
    
	cout<< var <<endl; 
	}();//Lambda表达式后面加()表示直接调用
}

//输出结果：10

3. [=]按值捕获父作用域的全部变量

int main()
{
    
	int var1 = 10;
	int var2 = 20;
	[=]() -> void {
    
		std::cout<< var1 <<" "<<var2 <<endl;
	}();//Lambda表达式后面加()表示直接调用
}
//输出结果 10 20

4. [&var]按引用捕获var变量

int main()
{
    
	int var = 10;
	[&var]() -> void{
    
	cout<< var <<endl; 
	}();//Lambda表达式后面加()表示直接调用
}

//输出结果：10

5. [&]按&捕获父作用域的全部变量

int main()
{
    
	int var1 = 10;
	int var2 = 20;
	[=]() -> void {
    
		std::cout<< var1 <<" "<<var2 <<endl;
	}();//Lambda表达式后面加()表示直接调用
}
//输出结果 10 20

6. [varl ,&var2]按值捕获var1变量，按引用捕获var2变量

int main()
{
    
	int var1 = 10;
	int var2 = 20;
	[]() -> void {
    
		std::cout<< var1 <<" "<<var2 <<endl;
	}();//Lambda表达式后面加()表示直接调用
}
//输出结果 10 20

2.1.2 按值捕获与按引用捕获的区别

按值捕获与按引用捕获区别与按值传参和按引用传参类似，按值捕获实际上就是Lambda将父作用域的变量临时拷贝一份给自己使用，故Lambda捕获到的变量不会影响到父作用域的变量。按引用捕获实际上就是Lambda将父作用域的变量起了一个别名给自己使用，两者指向的是同一块地址，故Lambda捕获到的变量会影响到父作用域的变量。

1 按值捕获

int main()
{
    
	int var1 = 10;
	int var2 = 20;
	//指定mutable，说明捕获到的参数可以被修改
	[var1,var2]()mutable -> void{
    
		cout<< var1 <<" "<<var2 <<endl;
		var1++;
		var2++;
	}();//Lambda表达式后面加()表示直接调用
	cout<< var1 <<" "<<var2 <<endl;
}

//输出结果：10 20
		   10 20   //没有影响父作用域的变量var1，var2

2 按引用捕获

int main()
{
    
	int var1 = 10;
	int var2 = 20;
	//指定mutable，说明捕获到的参数可以被修改
	[&var1,&var2]()mutable -> void{
    
		cout<< var1 <<" "<<var2 <<endl;
		var1++;
		var2++;
	}();//Lambda表达式后面加()表示直接调用
	cout<< var1 <<" "<<var2 <<endl;
}

//输出结果：10 20
		   11 21  //影响了父作用域的变量var1，var2

2.2 可变规则mutable

mutable修饰符， 默认情况下Lambda函数总是一个const函数，mutable可以取消其常属性。当在使用该修饰符时，参数列表不可省略（即使参数为空），当你需要匿名函数从外部捕获参数并在函数内部进行修改时，这个时候就可以使用mutable关键字。如下：

1. 匿名函数从外部按值捕获参数并在函数内部进行修改时，不使用mutable，程序报错。

int main()
{
    
	int var1 = 10;
	int var2 = 20;
	//不指定mutable，捕获到的参数不可以被修改
	[var1,var2]()-> void{
    
		cout<< var1 <<" "<<var2 <<endl;
		var1++;
		var2++;
	}();//Lambda表达式后面加()表示直接调用
	cout<< var1 <<" "<<var2 <<endl;
}

//输出结果：无法在非可变 lambda 中修改通过复制捕获

2. 匿名函数从外部按值捕获参数并在函数内部进行修改时，使用mutable，程序正常运行

int main()
{
    
	int var1 = 10;
	int var2 = 20;
	//指定mutable，说明捕获到的参数可以被修改
	[var1,var2]()mutable-> void{
    
		cout<< var1 <<" "<<var2 <<endl;
		var1++;
		var2++;
	}();//Lambda表达式后面加()表示直接调用
	cout<< var1 <<" "<<var2 <<endl;
}

//输出结果：10 20
		   11 21  //影响了父作用域的变量var1，var2

3. 匿名函数从外部按引用捕获参数并在函数内部进行修改时，不使用mutable，程序正常运行。

int main()
{
    
	int var1 = 10;
	int var2 = 20;
	//不指定mutable，捕获到的参数依旧可以被修改
	[&var1,&var2]()-> void{
    
		cout<< var1 <<" "<<var2 <<endl;
		var1++;
		var2++;
	}();//Lambda表达式后面加()表示直接调用
	cout<< var1 <<" "<<var2 <<endl;
}

//输出结果：10 20
		   11 21  //影响了父作用域的变量var1，var2

3 Lambda表达式的调用

Lambda调用有两种方式第一种方式是直接在匿名函数后面加一个括号直接进行调用，第二种方式是通过函数指针来进行调用，这里由于函数指针写的时候太过去累赘我们可以采用auto关键字来自动识别这个指针。如下所示

1. Lambda表达式后面加()表示直接调用

int main()
{
    
	int var1 = 10;
	int var2 = 20;
	//不指定mutable，捕获到的参数依旧可以被修改
	[&var1,&var2]()-> void{
    
		cout<< var1 <<" "<<var2 <<endl;
		var1++;
		var2++;
	}();//Lambda表达式后面加()表示直接调用
	cout<< var1 <<" "<<var2 <<endl;
}

2. 采用函数指针来调用Lambda表达式

int main()
{
    
	int var1 = 10;
	int var2 = 20;
	//不指定mutable，捕获到的参数依旧可以被修改
	auto f = [&var1,&var2]()-> {
    
		cout<< var1 <<" "<<var2 <<endl;
		var1++;
		var2++;
	};//Lambda表达式后面加()表示直接调用
	f();
	cout<< var1 <<" "<<var2 <<endl;
}

4 Lambda表达式的优缺点

4.1 Lambda表达式的优点

1. 可以直接在需要调用函数的位置定义短小精悍的函数，而不需要预先定义好函数
2. 使用Lamdba表达式变得更加紧凑，结构层次更加明显、代码可读性更好

例如Lambda在STL中的应用就体现了这一点

1. 我们写以一个找到数组中的奇数的函数在普通函数中的写法

#include<vector>
#include<algorithm>
#include<iostream>
using namespace std;

void find_num(vector<int> vec)
{
    
	//找到动态数组中的全部奇数
	for (int begin = 0; begin < vec.size(); begin++)
	{
    
		if (vec[begin] % 2 == 1)
		{
    
			cout << vec[begin] << endl;
		}
	}
}
int main()
{
    
	vector<int> vec = {
     1,3,9,7,8,10,19,20 };	
	find_num(vec);
	return 0;
}

2. 使用匿名函数的写法

int main()
{
    
	vector<int> vec = {
     1,3,9,7,8,10,19,20 };
	
	//find_num(vec);
	//每次遍历找到容器里面的数传到n中
	//[vec]捕获容器
	for_each(vec.begin(), vec.end(), [vec](int n)->void {
    
		if (n % 2 == 1)
		{
    
			cout << n << endl;
		}
		});
	return 0;
}

对比1.2两种写法可以完全体现出Lambda表达式的优势

4.2 Lambda表达式的缺点

1. Lamdba表达式语法比较灵活，增加了阅读代码的难度。
2. 对于函数复用无能为力

int main()
{
    
	int var1 = 10;
	int var2 = 20;
	//引用捕获
	auto f1 = [&var1]()mutable->int {
    
		var1++;
		return var1;
	};
	//值捕获
	auto f2 = [var2]()mutable->int {
    
		var2++;
		return var2;
	};

	cout << f1() << endl; //11
	cout << f1() << endl; //12

	cout << f2() << endl; //21
	cout << f2() << endl; //22

	cout << var1 << endl; //12 由于是引用捕获，故调用两次var1进行了两次累加
	cout << var2 << endl; //20 由于是值捕获，故调用两次var2还是不变
}

由这个例子我们可以知道：匿名函数居然可以函数嵌套函数，这是普通函数不能实现的，因为可以函数嵌套函数，所以在这个函数（main）的作用域下，f1，f2就相当于是一个变量，我们每次调用，就相当于每次都对同一个变量进行了修改，所以f1域f2两次调用的结果都不一样。这也说明了匿名函数的一个最大的缺点，对于函数的复用真的是无能为力。但是捕获变量var1,var2还是一样，看是如何捕获，值捕获，匿名函数内部对变量的修改不会影响函数外部，引用捕获就正好相反。

参考连接
C++ Lambda表达式详解
b站视频

最后希望大家多多三连，你们的鼓励就是对我最大的支持！谢谢