C++11_lambda表达式，包装器，bind绑定

1.lambda表达式

【捕捉列表】（参数列表）mutable ->返回值类型 {函数体}

mutable：默认条件下，lambda表达式默认具有const属性，mutable可以取消其const属性。注意：使用该修饰符时，参数列表即便为空也不能省略

参数列表在没有mutable时，如果为空可以省略，返回值类型也可以省略

[ ]：捕捉列表，在lambda表达式最开始，编译器可以捕捉上下文变量给lambda表达式使用，减少传参

捕获列表说明

捕捉列表描述了上下文中那些数据可以被lambda使用，以及使用的方式传值还是传引用。
[var]：表示值传递方式捕捉变量var
[=]：表示值传递方式捕获所有父作用域中的变量(成员函数中包括this)
[&var]：表示引用传递捕捉变量var
[&]：表示引用传递捕捉所有父作用域中的变量(包括this)
注意：
a. 父作用域指包含lambda函数的语句块
b. 语法上捕捉列表可由多个捕捉项组成，并以逗号分割
eg：

1. [=, &a, &b]：以引用传递的方式捕捉变量a和b，值传递方式捕捉其他所有变量
2. [&，a, this]：值传递方式捕捉变量a和this，引用方式捕捉其他变量

c. 捕捉列表不允许变量重复传递，否则就会导致编译错误。
eg：

[=, a]：=已经以值传递方式捕捉了所有变量，捕捉a重复

d. 在块作用域以外的lambda函数捕捉列表必须为空

e. lambda表达式之间不能相互赋值

eg:C++swap函数lambda表达式写法

#include<iostream>

using std::cout; using std::endl;

int main()
{
	int a = 10; int b = 20;
	auto swap = [](int& x, int& y)->void {int tmp = x; x = y; y = tmp; };
	//使用捕捉列表
	auto swap1 = [&a, &b] {int tmp = a; a = b; b = tmp; };//mutable取消lambda表达式的常量性
	auto swap2 = [&] {int tmp = a; a = b; b = tmp; };//引用全捕捉
	return 0;
}

C++11 lambda原理

lambda表达式被编译器转化为仿函数，类的名称为lambda+uuid字符串
eg：

调用仿函数的operator（）捕捉或者传递的参数都会以参数的形式传递给仿函数

所以lambda表达式不能相互赋值，因为两个lambda表达式的类型名不同

2.包装器

C++可调用对象类型有：
函数指针，仿函数，lambda表达式

#include<iostream>

using std::cout; using std::endl;

template<class F,class T>
T usF(F f, T t)
{
	static int a = 0;
	cout << a << endl;
	a++;
	cout << &a << endl;
	return f(a);
}

double fun(double num)
{
	return num / 2;
}

struct Functer
{
	double operator()(double Num)
	{
		return Num / 2;
	}
};

int main()
{
	//函数指针
	cout << usF(fun, 15.6) << endl;
	//仿函数
	cout << usF(Functer(), 12.4) << endl;
	//lambda表达式
	cout << usF([](double Num)->double {return Num / 2; }, 12.4) << endl;
	return 0;
}

分析上述代码：
上述函数模板会被实例化三次。

为了减少实例化对象，引出了包装器。将上述所有可调用对象进行封装，以统一的方式调用。

#include<iostream>
#include<functional>

using std::cout; using std::endl;

template<class F,class T>
T usF(F f, T t)
{
	static int a = 0;
	cout << a << endl;
	a++;
	cout << &a << endl;
	return f(a);
}

double fun(double num)
{
	return num / 2;
}

struct Functer
{
	double operator()(double Num)
	{
		return Num / 2;
	}
};

struct Functer1
{
	static double Print(double x)
	{
		cout << "Static" << endl;
		return x / 2;
	}
	double Print2(double x)
	{
		return x / 2;
	}
};

int main()
{

	//包装器函数指针
	std::function<double(double)>ff = fun;//std::function<double(double)>ff表示为参数为double返回值为double的可调用对象
	//包装仿函数
	std::function<double(double)>ff1 = Functer();
	//包装静态成员函数
	std::function<double(double)>ff2 = Functer1::Print;
	// 包装非静态的成员函数
	std::function<double(Functer1, double)>ff3 = &Functer1::Print2;//this指针
	cout << ff3(Functer1(), 12.3) << endl;//调用时需要对象才可以调用
	//包装lambda表达式
	auto tmp = [](double num)->double {return num / 2; };
	std::function<double(double)>ff4 = tmp;
	cout << usF(ff, 12.4) << endl;
	cout << usF(ff1, 12.4) << endl;
	cout << usF(ff2, 12.4) << endl;
	cout << usF(ff4, 12.4) << endl;

	return 0;
}

根据上述代码可知，如果参数以及返回值类型相同，不管是那种可调用类型都可以通过相同的包装器表示。这样传递给模板函数时就可以减少实例化个数

bind绑定

std::bind函数在functional头文件中，是一个通用函数适配器，接受一个对象，生成一个新的可调用对象来适应原来对象的参数列表

#include<iostream>
#include<functional>

using std::cout; using std::endl;

struct Sub
{
	int sub(int a, int b)
	{
		return a - b;
	}
};

int Add(int a, int b)
{
	return a + b;
}

int main()
{
	//将Add函数绑定为参数+10
	std::function<int(int)>ff = std::bind(Add, std::placeholders::_1, 10/*std::placeholders::_2*/);//接受两个参数，第一个参数给_1，第二个参数给_2
	cout << ff(12) << endl;

	//非静态成员函数调用需要对象，绑定传参对象
	std::function<int(int, int)>ff1 = std::bind(&Sub::sub, Sub(), std::placeholders::_1, std::placeholders::_2);
	cout << ff1(12, 10) << endl;
	return 0;
}

还可以控制传参顺序，只要调整std::placeholders::_1, std::placeholders::_2顺序即可