c++ 11

lambda表达式

语法：
[capture-list] (parameters)mutable->return-type{statement}

• [capture-list] :捕捉列表，该列表总是出现在lambda函数开始的位置，编译器根据[]来判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda函数使用。
• （parameters): 参数列表。与普通函数的参数列表一致，如果不需要传递参数，可以连同（）一起省略。
• mutable：默认情况，lambda函数总是一个const函数，mutable可以取消传值变量的常性，使用该修饰符时，参数列表不可省略。
• ->returntype :返回值类型。没有返回值可以省略。返回值类型明确的情况下，也可以省略。
• {statement}：函数体，在该函数体内，除了可以使用其参数，还可以使用所有捕获的变量。

void test()
{
	//最简单的lambda
	[]{};
	//
	int a = 3, b = 4;
	[=] {return a + b;};
	//
	auto fun1 = [&](int c){ b = a + c;};
	fun1(3);
	cout << b;

	//各部分都完整的lambda
	auto fun2 = [=, &b](int c)->int {return b += a + c;};
	cout << fun2(10);
	cout << b;


	//复制捕捉x
	int x = 10;
	auto add_x = [x](int a)mutable->int {x *= 2;return x + a;};
	cout << add_x(10);

}

注意事项

1.捕捉列表的说明：

• [var] : 表示值传递方式捕捉变量var
• [=] ： 表示值传递方式捕捉所有父作用域中的变量
• [&var] : 表示引用传递捕捉变量var
• [&] : 表示引用传递捕捉所有父作用域中的变量
• [this] : 表示值传递方式捕捉当前的this指针。

注意：
a. 父作用域指包含lambda函数的语句块
b. 语法上捕捉列表可由多个捕捉项组成，并以逗号分隔。
[=,&a,&b] ：引用传递捕捉a,b 其余变量值传递捕捉。

c. 捕捉列表不允许变量重复传递，不然编译报错。
[=,a] : 报错

d. 在块作用域以外的lambda函数捕捉列表必须为空
e. lambda表达式之间不能相互赋值。

void otest()
{
	auto f1 = [] {cout << "f1";};
	auto f2 = [] {cout << "f2";};
	//不能f1 = f2,但是可以拷贝构造
	auto f3(f2);

	f3();
	//也可以将lambda表达式赋值给相同类型的函数指针。
	void(*PF)();
	PF = f3;
	PF();

}

函数对象与lambda表达式

函数对象，又称为仿函数，就是在类中重载了operator()运算符的类对象。

实际在底层编译器对于lambda表达式的处理方式，完全就是按照函数对象的方式处理的，即：如果定义了一个lambda表达式，编译器会自动生成一个类，类型名称为lambda_uuid,并重载（）运算符。

什么是uuid？

UUID 是 通用唯一识别码（Universally Unique Identifier）的缩写，是一种软件建构的标准，亦为开放软件基金会组织在分布式计算环境领域的一部分。其目的，是让分布式系统中的所有元素，都能有唯一的辨识信息，而不需要通过中央控制端来做辨识信息的指定。如此一来，每个人都可以创建不与其它人冲突的UUID。在这样的情况下，就不需考虑数据库创建时的名称重复问题。

包装器

function包装器
function包装器也叫适配器。 c++中的function本质是一个类模板，也是一个包装器。

template<class F,class T>
T useF(F f, T x)
{
	static int count = 0;
	cout << "count :" << ++count << endl;
	return f(x);


}

double f(double i)
{
	return i / 2;
}

struct Functor
{
	double operator()(double d)
	{
		return d / 3;
	}


};



int main()
{
	useF(f, 11.11);
	useF(Functor(), 11.11);
	useF([](double d)->double{return d / 4;}, 11.11);



	return 0;
}

上述代码，useF函数模板实例化了三份！这样会导致模板的效率低下！

包装器可以很好解决上述问题

std::function在头文件 < functional > 中
template<class Ret,class… Args>
class function<Ret(Args…)>;
Ret: 被调用函数的返回类型
Args… ：被调用函数的形参

template<class F,class T>
T useF(F f, T x)
{
	static int count = 0;
	cout << "count :" << ++count << endl;
	return f(x);


}

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

struct Functor
{
	int operator()(int a,int b)
	{
		return a + b;
	}


};

class Plus
{
public:
	static int plusi(int a, int b)
	{
		return a + b;
	}
	double plusd(double a, double b)
	{
		return a + b;
	}

};



int main()
{
	//函数名
	function<int(int, int)> func1 = f;

	//函数对象
	function<int(int, int)> func2 = Functor();

	//lambda表达式
	function<int(int, int)> func3 = [](int a, int b)->int {return a + b;};

	//类的成员函数
	function<int(int, int)> func4 = &Plus::plusi;

	function<double(Plus,double, double)> func5 = &Plus::plusd;


	return 0;
}

bind

bind是一个函数模板，就像一个函数包装器，接受一个可调用对象(callable object), 生成一个新的可调用对象来适应原参数列表。

function<int(int, int)> func1 = bind(&Plus::plusd,Plus(), placeholders::_1, placeholders::_2);
	function<int(int, int)> func2 = bind(f, 1, placeholders::_1);
	function<int(int, int)> func3 = bind(&Plus::plusi, 1, 2);