C++11新增特性：可变参数模板、lambda表达式、function包装器、bind绑定、defult和delete

Hello大家好！ 很高兴与大家见面！ 给生活添点快乐，开始今天的编程之路。

我的博客: <但愿.

我的专栏: C语言、题目精讲、算法与数据结构、C++

欢迎点赞，关注

目录

一可变参数模板

1.1可变参数模板的基本语法

1.2 可变参数模板的原理

1.3 包扩展

1.3.1 包扩展概念

1.3.2包扩展实现方法

1.4 empalce系列接⼝

1.4.1empalce系列接⼝说明

1.4.2empalce系列性能上的提升

1.4.2.1对于普通类型上的提升

1.4.2.2对于符合类型上的提升

1.4.2.3empalce系列接⼝的使用

二新的类功能

2.1 默认的移动构造和移动赋值

2.2成员变量声明时给缺省值

2.3 defult和delete

2.4 final与override

三STL中⼀些变化

四 lambda

4.1 lambda

4.1.1 lambda语法/特点

4.1.2lambda几个问题

4.1.3lambda示例

4.2 捕捉列表

4.2.1捕捉列表的语法/规则

4.2.2捕捉列表的使用和问题

4.3 lambda的应⽤

4.4 lambda的原理

五包装器

5.1 function

5.1.1 function的语法/特点

5.1.2 function的定义

5.1.3 function的应用

5.2bind(绑定)

5.2.1bind的语法/特点

5.2.2bind和function的不同

5.2.3bind的示例

5.2.4bind的应用

一 可变参数模板

1.1 可变参数模板的基本语法

• C++11⽀持可变参数模板，也就是说⽀持可变数量参数的函数模板和类模板，可变数⽬的参数被称 为参数包，存在两种参数包：模板参数包，表⽰零或多个模板参数；函数参数包：表⽰零或多个函 数参数。
• template <class ...Args> void Func(Args... args) {}
• template <class ...Args> void Func(Args&... args) {} 【左值】
• template <class ...Args> void Func(Args&&... args) {} 【万能】
• 我们⽤省略号来指出⼀个模板参数或函数参数的表⽰⼀个包，在模板参数列表中，class...或 typename...指出接下来的参数表⽰零或多个类型列表；在函数参数列表中，类型名后⾯跟...指出接下来表⽰零或多个形参对象列表；函数参数包可以⽤左值引⽤或右值引⽤表⽰，跟前⾯普通模板 ⼀样，每个参数实例化时遵循引⽤折叠规则。
• 可变参数模板的参数个数是不确定的那我们怎么求其参数的个数呢？C++11引入sizeof...运算符去计算参数包中参数的个数。

1.2 可变参数模板的原理

总结：可变参数模板的原理跟模板类似，本质还是去实例化对应类型和个数的多个函数。

解析：其本质还是一个模板，本质生成对应的一些函数，实例化出多个函数。因为我们实际上调用的不是这个模板，而是调用实例化出来的。

模板函数：代表任意类型的任意多个参数的一个函数。

可变参数模板：是模板的进一步泛型化(由参数个数决定，有几个参数就会实例化出几个函数。

【示例】

要实现一个打印函数，参数是0、1、2、3.....个，在没有可变参数之前我们要自己手动分别实现0、1、2、3...个参数的打印函数；有可变模板参数的情况下，实现一个可变参数模板函数可以代替使用函数(在调用时自己回推导)。但是其底层时不变的都是实例化调用对应的函数。

【示例 一个打印函数】

//一定要注意在不同时候...的位置
template<class ...Args>
void  Print(Args&&... args)
{
	cout << sizeof...(args) << endl;
}


int main()
{
	double x = 2.2;
	Print(); // 包⾥有0个参数
	Print(1); // 包⾥有1个参数
	Print(1, string("xxxxx")); // 包⾥有2个参数
	Print(1.1, string("xxxxx"), x); // 包⾥有3个参数
	
	//在有可变参数模板时其原理是会结合引⽤折叠规则实例化出以下四个函数
	void Print();
	void Print(int&& arg1);
	void Print(int&& arg1, string && arg2);
	void Print(double&& arg1, string && arg2, double& arg3);

	//在没用可变参数模板时，我们实现出这样的多个函数模板才能⽀持这样的功能
	void Print();
	template <class T1>
	void Print(T1 && arg1);
	template <class T1, class T2>
	void Print(T1 && arg1, T2 && arg2);
	template <class T1, class T2, class T3>
	void Print(T1 && arg1, T2 && arg2, T3 && arg3);
	// ...
	return 0;
}

1.3 包扩展

1.3.1 包扩展概念

前面讲了可变参数模板包，那我们怎么对其扩展呢？
• 对于⼀个参数包，我们除了能计算他的参数个数，我们能做的唯⼀的事情就是扩展它，当扩展⼀个 包时，我们还要提供⽤于每个扩展元素的模式，扩展⼀个包就是将它分解为构成的元素，对每个元 素应⽤模式，获得扩展后的列表。我们通过在模式的右边放⼀个省略号(...)来触发扩展操作。底
• C++还⽀持更复杂的包扩展，直接将参数包依次展开依次作为实参给⼀个函数去处理。

1.3.2包扩展实现方法

【方法一 不行】

前面我们讲了sizeof...运算符去计算参数包中参数的个数。这里我们可不可以利用这个特性在像容器中一样调用[ ]呢？

template <class ...Args>
void Print(Args... args)
{
	 // 不支持
	 // 可变参数模板编译时解析
	 // 下面是运行获取和解析，所以不支持这样用
	 cout << sizeof...(args) << endl;
	 for (size_t i = 0; i < sizeof...(args); i++)
	 {
		cout << args[i] << " ";
	 }
	 cout << endl;
}

int main()
{
	double x = 2.2;
	//Print(); // 包里有0个参数
	Print(1); // 包里有1个参数
	Print(1, string("xxxxx")); // 包里有2个参数
	Print(1.1, string("xxxxx"), x); // 包里有3个参数

	return 0;
}

这种方法是不可行的，要想使用[ ]和容器一样进行访问，储存的类型一定是相同的，但是可变模板参数包的参数类型是不确定的，所以这里是不可以用这种方法实现的。(C++11不支持容器中存放不同类型的变量，C++17支持容器中存放不同类型的变量)

【方法二：先扩展出一个可变模板参数包中的参数，在递归调用。当可变模板参数包中的参数没用时结束递归即可】

//template <class T, class ...Args>
//void ShowList(T x, Args... args)
//{
//	// 不能这么写，这是运行时判断逻辑
//  //因为sizeof...是编译器用模板参数推导的
//	if (sizeof...(args) == 0)
//		return;
//
//	cout << x << " ";
//	ShowList(args...);
//}

//对于可变模板参数包中没用参数时要结束递归
//但是不能在递归函数中进行，因为在递归函数中写是运行时判断逻辑
void ShowList()
{
	cout << endl;
}

template <class T, class ...Args>
void ShowList(T x, Args... args)
{
	cout << x << " ";
	ShowList(args...);
}

template <class ...Args>
void Print(Args... args)
{
	// N个参数，第一个传给x，剩下N-1参数传给ShowList的第二个参数包
	ShowList(args...);
}

int main()
{
	double x = 2.2;
	Print(1.1, string("xxxxx"), x); // 包里有3个参数

	return 0;
}

【包扩展原理】

void ShowList()
{
	cout << endl;
}
//注意...的位置，在形参中在后面
template <class T, class ...Args>
void ShowList(T x, Args... args)
{
	cout << x << " ";
	ShowList(args...);
}

template <class ...Args>
void Print(Args... args)
{
	// N个参数，第一个传给x，剩下N-1参数传给ShowList的第二个参数包
	ShowList(args...);
}

//原理还是实例化出对应多个参数的函数
////void ShowList(double x)
////{
////	cout << x << " ";
////	ShowList();
////}
////
////void ShowList(string x, double x3)
////{
////	cout << x << " ";
////	ShowList(x3);
////}
////
////void ShowList(int x, string x2, double x3)
////{
////	cout << x << " ";
////	ShowList(x2, x3);
////}
////
////void Print(int x1, string x2, double x3)
////{
////	ShowList(x1, x2, x3);
////}



int main()
{
	double x = 2.2;
	Print(1.1, string("xxxxx"), x); // 包里有3个参数

	return 0;
}

【图解】

【总结】

了解这个，因为我们很少实现可变模板参数包，只有在实现中间键库才要使用。而扩展包要通过递归实现，所以要解析参数包中的内容很恶心，必须要在多个函数中获取【本质是恶心编译器，增加编译器的负担，编译器要推导参数包中参数个数和参数类型】。

1.4 empalce系列接⼝

1.4.1empalce系列接⼝说明

• template <class... Args> void emplace_back (Args&&... args);
• template <class... Args> iterator emplace (const_iterator position, Args&&... args);
• C++11以后STL容器新增了empalce系列的接⼝，empalce系列的接⼝均为模板可变参数，功能上 兼容push和insert系列，但是empalce还⽀持新玩法，假设容器为container<T>，empalce还⽀持 直接插⼊构造T对象的参数，这样有些场景会更⾼效⼀些，可以直接在容器空间上构造T对象。
• emplace_back总体⽽⾔是更⾼效，推荐以后使⽤emplace系列替代insert和push系列
• 第⼆个程序中我们模拟实现了list的emplace和emplace_back接⼝，这⾥把参数包不段往下传递， 最终在结点的构造中直接去匹配容器存储的数据类型T的构造，所以达到了前⾯说的empalce⽀持 直接插⼊构造T对象的参数，这样有些场景会更⾼效⼀些，可以直接在容器空间上构造T对象。
• 传递参数包过程中，如果是 Args&&... args 的参数包，要⽤完美转发参数包，⽅式如下
std::forward<Args>(args)... ，否则编译时包扩展后右值引⽤变量表达式就变成了左值。

1.4.2empalce系列性能上的提升

1.4.2.1对于普通类型上的提升

int main()
{

	wzy::list<wzy::string> lt2;
	// 传左值效率用法都是一样的
	wzy::string s1("111111111");
	lt2.push_back(s1);
	lt2.emplace_back(s1);
	cout << "*****************************************" << endl;
	// 传右值效率用法都是一样的
	wzy::string s2("111111111");
	lt2.push_back(move(s2));
	wzy::string s3("111111111");
	lt2.emplace_back(move(s3));
	cout << "*****************************************" << endl;
	// emplace_back的效率略高一筹
	lt2.push_back("1111111111111111111111111111");
	lt2.emplace_back("11111111111111111111111111");
	cout << "*****************************************" << endl;
}

【运行结果分析】

1.4.2.2对于符合类型上的提升

一定要注意传参时的写法

例如在list中插入pair类型

lt3.push_back({"11111111111111", 1});

//lt3.emplace_back({ "11111111111111", 1 }); //不支持

lt3.emplace_back("11111111111111", 1);

为什么emplace系列不支持{ }构造，因为{ }底层会转化成std::initializer_list，而emplace会调用对应的构造，只有对象对应的构造函数支持{}构造才可以使用{ } 对emplace系列传参

int main()
{
	
	wzy::list<pair<wzy::string, int>> lt3;
	// 传左值效率用法都是一样的
	pair<wzy::string, int> kv1("xxxxxx", 1);
	lt3.push_back(kv1);
	lt3.emplace_back(kv1);
	cout << "*****************************************" << endl;
	// 传右值效率用法都是一样的
	pair<wzy::string, int> kv2("xxxxxx", 1);
	lt3.push_back(move(kv2));
	pair<wzy::string, int> kv3("xxxxxx", 1);
	lt3.emplace_back(move(kv3));
	cout << "*****************************************" << endl;
	// emplace_back的效率略高一筹
	lt3.push_back({"11111111111111", 1});
	//lt3.emplace_back({ "11111111111111", 1 }); //不支持
	lt3.emplace_back("11111111111111", 1);
	cout << "*****************************************" << endl;

	return 0;
}

【运行结果分析】

1.4.2.3empalce系列接⼝的使用

注意虽然empalce系列接⼝的性能有所提升，但是要怎么使用，只有在传构造函数参数时emplace系列的性能才有所提升，其他情况和普通接口的性能一样。注意在使用emplace对于复合类型的操作的传参。

二 新的类功能

2.1 默认的移动构造和移动赋值

• 原来C++类中，有6个默认成员函数：构造函数/析构函数/拷⻉构造函数/拷⻉赋值重载/取地址重载/const 取地址重载，最后重要的是前4个，后两个⽤处不⼤，默认成员函数就是我们不写编译器 会⽣成⼀个默认的。C++11 新增了两个默认成员函数，移动构造函数和移动赋值运算符重载。
•默认移动构造生成条件 ：
只有自己未实现移动构造函数，且没有实现析构函数 、拷⻉构造、拷⻉赋值重载(因为这三个常常绑定在一起，生成其中一个另外两个通常也要生成) ,此时编译器会⾃动⽣成⼀个默认移动构造。
• 默认移动构造生成特点：
默认⽣成的移动构造函数，对于内置类型成员会执⾏逐成员按字节拷⻉，⾃定义类型成员，则需要看这个成员是否实现移动构造，如果实现了就调⽤ 移动构造，没有实现就调⽤拷⻉构造。
• 默认移动赋值生成条件：
只有自己未实现移动赋值重载函数，且没有实现析构函数 、拷⻉构造、拷⻉赋值重载，此时编译器会⾃动⽣成⼀个默认移动赋值。
• 默认移动赋值特点：
默认⽣成的移动构造函数，对于内置类型成员会 执⾏逐成员按字节拷⻉，⾃定义类型成员，则需要看这个成员是否实现移动赋值，如果实现了就调 ⽤移动赋值，没有实现就调⽤拷⻉赋值。(默认移动赋值跟上⾯移动构造完全类似)
• 如果你提供了移动构造或者移动赋值，编译器不会⾃动提供拷⻉构造和拷⻉赋值。

【示例】

class Person
{
public:
	Person(const char* name = "", int age = 0)
		:_name(name)
		, _age(age)
	{
	}
	Person(const Person& p)
	:_name(p._name)
	,_age(p._age)
	{}
	Person& operator=(const Person& p)
	{
	if(this != &p)
	{
	_name = p._name;
	_age = p._age;
	}
	return *this;
	}
	~Person()
{}
private:
	wzy::string _name;
	int _age;
};
int main()
{
	Person s1;
	Person s2 = s1;
	Person s3 = std::move(s1);
	Person s4;
	s4 = std::move(s2);
	return 0;
}

【运行结果】

【1实现了析构函数 、拷⻉构造、拷⻉赋值重载其中一个甚至多个】

在自己未实现 移动构造和移动赋值的情况下，只要实现了析构函数 、拷⻉构造、拷⻉赋值重载其中一个甚至多个，编译器就不会生成默认移动构造和默认移动赋值。

【2没有实现析构函数 、拷⻉构造、拷⻉赋值重载】

2.2成员变量声明时给缺省值

前面在入门C++中已经讲过，即 成员变量声明时给缺省值是给初始化列表⽤的，如果没有显⽰在初始化列表初始化，就会在初始化列 表⽤这个缺省值初始化，

2.3 defult和delete

【定义/作用】

• defult：(强制生成默认函数，C++11提供这个是为了更好的控制要使⽤默认函数）
想要使⽤某个默认的函数，但是因为⼀些原因 这个函数没有默认⽣成。⽐如：我们提供了拷⻉构造，就不会⽣成移动构造了，那么我们可以使⽤ default关键字显⽰指定移动构造⽣成。
• delete：(强制不生成默认函数)
想要限制某些默认函数的⽣成，在C++98中，是该函数设置成private，并且只声明不定义(设置为private，为了防止设置成公有即使自己没用定义，但是此时为公有函数别人在类为可以补充)， 这样只要其他⼈想要调⽤就会报错。在C++11中更简单，只需在该函数声明加上=delete即可，该语 法指⽰编译器不⽣成对应函数的默认版本，称=delete修饰的函数为删除函数。

【示例】

【defult：在已经实现了析构函数 、拷⻉构造、拷⻉赋值重载其中一个甚至多个，本来无法生成默认移动构造，但是使用defult强制生成默认移动构造】

class Person
{
public:
	Person(const char* name = "张三", int age = 1)
		:_name(name)
		, _age(age)
		, _i(11)
	{
	}

	// 委托构造-新语法可能在一些书中或者平台中可能看到
	Person(int i, const char* name = "张三", int age = 1)
		:Person(name, age)
	{
		_i = i;
	}

	// 强制生成
	Person(Person&& p) = default;

	Person& operator=(const Person& p)
	{
		if(this != &p)
		{
			_name = p._name;
			_age = p._age;
		}
		return *this;
	}

	~Person()
	{}

private:
	wzy::string _name;
	int _age;
	int _i = 0;
};

int main()
{
	Person s1;
	Person s2 = s1;			   // 拷贝构造
	Person s3 = std::move(s1); // 移动构造
	/*Person s4;
	s4 = std::move(s2);*/

	return 0;
}

【运行结果】

【delete：强制不可以生成构造函数，因为一些变量可能不希望被拷贝，此时就可以使用】

class Person
{
public:
	Person(const char* name = "张三", int age = 1)
		:_name(name)
		, _age(age)
		, _i(11)
	{
	}

	// 委托构造-新语法可能在一些书中或者平台中可能看到
	Person(int i, const char* name = "张三", int age = 1)
		:Person(name, age)
	{
		_i = i;
	}

	// 强制不让生成，不期望这个类的对象被拷贝
	Person(const Person& p) = delete;

	Person(const Person& p)
		:_name(p._name)
		,_age(p._age)
	{}

	// 强制生成
	//Person(Person&& p) = default;

	Person& operator=(const Person& p)
	{
		if(this != &p)
		{
			_name = p._name;
			_age = p._age;
		}
		return *this;
	}

	~Person()
	{}

private:
	wzy::string _name;
	int _age;
	int _i = 0;
};

int main()
{
	Person s1;
	Person s2 = s1;			   // 拷贝构造
	Person s3 = std::move(s1); // 移动构造
	/*Person s4;
	s4 = std::move(s2);*/

	return 0;
}

【运行结果】

因为无构造函数所以编译器会报错。

2.4 final与override

前面在C++入门中已经讲过这里我只总结一下其作用

• fina

如果使用fina修饰类，类不能被继承。

如果使用fina修饰虚函数，虚函数不能被重写。

• override

用于判断派生类中虚函数是否完成重写。

三 STL中⼀些变化

从上图可以知道C++11增加了：
• 新增加的容器

array、forward_list、unordered_map/unordered_set；其中unordered_set/unordered_map(哈希表)用的较多，其他没什么用。

array:静态数组(通过非类型模板实现，不支持插入...操作)；从开空间的角度分析(array和vector相比):array开空间的效率更高，因为vector是在堆上开空间要走malloc那一套机制，而array直接在栈上开空间(不用走malloc机制所以效率更高)，所以在少量开空间的情况先还可以所以vector，如果要大量高频开空间所以array更好(但是这种情况很少)。

forward_list(单链表)：现实中很少用因为其是单向的对于头部的操作效率很高，但是对于尾部的操作效率就很低下了。

• STL中容器的新接⼝
STL中容器的新接⼝也不少，最重要的就是右值引⽤和移动语义相关的push/insert/emplace系列接⼝和移动构造和移动赋值，还有initializer_list版本的构造等，还有⼀些⽆关痛痒的如cbegin/cend等需要时查查⽂档即可。
右值引⽤和移动语义相关的push/insert/emplace系列接⼝和移动构造和移动赋值：前面讲过通过对于深拷贝类型的效率
initializer_list：初始化列表的底层
swap交换函数：
C++98：算法库中的swap，要拷贝构造，拷贝复制重载，对于深拷贝类型不友好，而容器中自己实现的swap接口也是间接的调用算法库中的swap函数。
C++11：统一实现了两个；有移动构造调用移动构造，没用移动构造调用拷贝构造；还支持数组形式交换。
• 容器的范围for遍历

四 lambda

4.1 lambda

4.1.1 lambda语法/特点

• lambda 表达式本质是⼀个匿名函数对象，跟普通函数不同的是他可以定义在函数内部。
lambda 表达式语法使⽤层⽽⾔没有类型，所以我们⼀般是⽤auto或者模板参数定义的对象去接收 lambda 对象。
• lambda表达式的格式： [capture-list] (parameters)-> return type { function boby }
• [capture-list] : 捕捉列表 ，该列表总是出现在 lambda 函数的开始位置，编译器根据[]来
判断接下来的代码是否为 lambda 函数，捕捉列表能够捕捉上下⽂中的变量供 lambda 函数使⽤，捕捉列表可以传值和传引⽤捕捉，具体细节下面我们再细讲。 捕捉列表为空也不能省略。
• (parameters) ：参数列表 ，与普通函数的参数列表功能类似， 如果不需要参数传递，则可以连同()⼀起省略
• ->return type ：返回值类型 ，⽤追踪返回类型形式声明函数的返回值类型， 没有返回值时此部分可省略。⼀般返回值类型明确情况下，也可省略，由编译器对返回类型进⾏推导。
• {function boby} ：函数体， 函数体内的实现跟普通函数完全类似， 在该函数体内，除了可以使⽤其参数外，还可以使⽤所有捕获到的变量，函数体为空也不能省略。

4.1.2lambda几个问题

• 注意其是定义出一个新的可调用对象；前面我们的可调用对象有函数指针、仿函数，加上这个，现在有三个可调用对象：函数指针、仿函数、lambda。

为什么在有函数指针、仿函数两个可调用对象，还要实现lambda：

首先函数指针和数组指针是指针中两个很恶心的东西，和常规定义都不相同，它们嵌在中间定义的，所以C++不到万不得已不会用这个；而对于仿函数而言，其是一个类，类中重载operator ( )，它的对象就可以用运算符重载调用operator ( )，就可以确定这个对象可以像函数一样调用，但是其本质还是一个类，在一些场景还是太重了；有因为这里要传可调用对象，前面两个就不合适了，为了解决这个问题C++11引入lambda(即一开始有函数指针，但是其比较复杂不到万不得已不会用这个，从而引入仿函数，但是仿函数要通过类重载operator ( )实现，太重了此时就引入lambda。

• lambda要配合auto使用

因为lambda生成的对象类型是不知道的我们拿不到编译器生成的名字是随机的(后面会讲)，也就意味着lambda只能传2个地方（即让编译器自动推导）:auto、模板【decltype可以推一个对象的类型】

• lambda定义位置

lambda可以定义在全局也可以定义在局部，只是定义在不同的头发对于捕捉列表的要求不同，我们一般定义在局部

•lambda定义出的对象叫匿名函数对象

因为其表达式和函数相比就少了函数名

•lambda定义出的本质

写一些短小函数解决仿函数太重的问题

4.1.3lambda示例

int main()
{
// ⼀个简单的lambda表达式
auto add1 = [](int x, int y)->int {return x + y; };
cout << add1(1, 2) << endl;
// 1、捕捉为空也不能省略
// 2、参数为空可以省略
// 3、返回值可以省略，可以通过返回对象⾃动推导
// 4、函数题不能省略
auto func1 = []
{
cout << "hello bit" << endl;
return 0;
};
func1();
int a = 0, b = 1;
auto swap1 = [](int& x, int& y)
{
int tmp = x;
x = y;
y = tmp;
};
swap1(a, b);
cout << a << ":" << b << endl;
return 0;
}

4.2 捕捉列表

4.2.1捕捉列表的语法/规则

• 为什么要用捕捉列表
lambda 表达式中默认只能⽤ lambda 函数体和参数中的变量，如果想⽤外层作⽤域中的变量就需要进⾏捕捉 。
• 捕捉⽅式
第⼀种捕捉⽅式是 在捕捉列表中显⽰的传值捕捉和传引⽤捕捉 ，捕捉的多个变量⽤逗号分割。[x， y， &z] 表⽰x和y值捕捉，z引⽤捕捉。
• 第⼆种捕捉⽅式是 在捕捉列表中隐式捕捉，我们在捕捉列表写⼀个=表⽰隐式值捕捉，在捕捉列表写⼀个&表⽰隐式引⽤捕捉，这样我们 lambda 表达式中⽤了那些变量，编译器就会⾃动捕捉那些变量。
• 第三种捕捉⽅式是在捕捉列表中混合使⽤隐式捕捉和显⽰捕捉。[=, &x]表⽰其他变量隐式值捕捉，x引⽤捕捉；[&, x, y]表⽰其他变量引⽤捕捉，x和y值捕捉。当使⽤混合捕捉时，第⼀个元素必须是&或=，并且&混合捕捉时，后⾯的捕捉变量必须是值捕捉，同理=混合捕捉时，后⾯的捕捉变量必须是引⽤捕捉。
• 前面已经讲了lambda定义在不同地方捕捉列表的要求不同
lambda 表达式 如果在函数局部域中，他可以捕捉 lambda 位置之前定义的变量，不能捕捉静态局部变量和全局变量，静态局部变量和全局变量也不需要捕捉 (因为静态局部变量和全局变量的生命周期是全局的） ， lambda 表达式中可以直接使 ⽤。 这也意味着 lambda 表达式如果定义在全局位置，捕捉列表必须为空。
• lambda 捕捉列表中只属性的变化
默认情况下 ， lambda 捕捉列表是被const修饰的，也就是说传值捕捉的过来的对象不能修改， mutable加在参数列表的后⾯可以取消其常量性，也就说使⽤该修饰符后，传值捕捉的对象就可以修改了，但是修改还是形参对象，不会影响实参(想要影响实参就用引用捕捉）。使⽤该修饰符后，参数列表不可省略(即使参数为空)。

4.2.2捕捉列表的使用和问题

**•**捕捉列表可以捕捉不同地方的变量，

捕捉列表可以捕捉的变量范围要看lambda定义的位置，位置不同捕捉列表可以捕捉的变量范围也不同，例如如果定义在局部函数，那么只能捕捉当前局部函数中作用域的变量。

**•**使用

要经常用这些变量，就在局部不想传参就用，对于普通的函数要传参，而对于lambda只有进行捕捉即可。注意如果使用隐式捕捉或者引用捕捉，虽然在语法层面上可以捕捉全部变量，但是编译器会看你用了哪几个，用了哪几个编译器就会捕捉哪几个其他的不会捕捉。

**•**捕捉方式

传值捕捉：把其拷贝过来(并且两个不是同一个变量，从某种程度上可以认为和传值传参一样与外面对象不是同一个。

隐式引用捕捉： 想捕捉过来的变量可以被修改，并且能影响外面就用引用捕捉，但是这里语法方式很恶心例如 [&a] =》&a在之前不是指针吗？前面的引用是跟在类型后面：int& a; 而指针才是在对象前面，用于捕捉列表是不能传类型的(传来不就和函数参数列表一样)，这也是这里语法的恶心之处。

混合捕捉：其中一个想要引用捕捉其他想用传值捕捉(=）；其中一个想要传值捕捉其他想用引用捕捉时就使用(&)，但是注意使用混合捕捉时其顺序时固定的：第一个一定是隐式捕捉（& =）。

**•**哪些对象可以捕捉

是否可以捕捉要看其生命周期和作用域，定义在全局的原因全局变量的生命周期是全局的所以不用捕捉，所以定义在全局的lambda的捕捉列表一定为空。

对于定义在局部的lambda:由于静态变量的生命周期是全局的所以不用捕捉，此时只会捕捉局部对象。

【示例】

//1定义在全局
int x = 0;
// 捕捉列表必须为空，因为全局变量不用捕捉就可以用，没有可被捕捉的变量
auto func1 = []()
	{
		x++;
	};

int main()
{
	// 只能用当前lambda局部域和捕捉的对象和全局对象
	int a = 0, b = 1, c = 2, d = 3;
	auto func1 = [a, &b]
	{
		// 值捕捉的变量不能修改，引用捕捉的变量可以修改
		//a++;
		b++;
		int ret = a + b;
		return ret;
	};
	cout << func1() << endl;

	// 隐式值捕捉
	// 用了哪些变量就捕捉哪些变量
	auto func2 = [=]
	{
		int ret = a + b + c;
		return ret;
	};
	cout << func2() << endl;

	// 隐式引用捕捉
	// 用了哪些变量就捕捉哪些变量
	auto func3 = [&]
	{
		a++;
		c++;
		d++;
	};
	func3();
	cout << a << " " << b << " " << c << " " << d << endl;

	// 混合捕捉
	auto func4 = [&, a]
	{
		//a++;
		b++;
		c++;
		d++;
	};
	func4();
	cout << a << " " << b << " " << c << " " << d << endl;

	auto func5 = [&, a]()mutable
	{
		a++;
		b++;
		c++;
		d++;
	};
	func5();
	cout << a << " " << b << " " << c << " " << d << endl;

	return 0;
}

4.3 lambda的应⽤

**•**解决在一个地方要传可调用对象，由于函数指针，和仿函数的不足而使用lambda，定义在局部很好用，当前定义当前使用，对于所有lambda我们可以不用写注释别人一看就懂，也不用取名，因为只是一个匿名函数对象

**•**只要想定义一个局部(全局也可以只是很少定义在全局)，当前定义当前使用的函数，就可以使用lambda。

【示例实现一个商品的排序，排序依据可能有多个方面】

struct Goods
{
	string _name; // 名字
	double _price; // 价格
	int _evaluate; // 评价
	// ...

	Goods(const char* str, double price, int evaluate)
		:_name(str)
		, _price(price)
		, _evaluate(evaluate)
	{
	}
};

struct ComparePriceLess
{
	bool operator()(const Goods& gl, const Goods& gr)
	{
		return gl._price < gr._price;
	}
};

struct ComparePriceGreater
{
	bool operator()(const Goods& gl, const Goods& gr)
	{
		return gl._price > gr._price;
	}
};

int main()
{
	vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2, 3}, { "菠萝", 1.5, 4 } };
	// 类似这样的场景，我们实现仿函数对象或者函数指针支持商品中
	// 不同项的比较，相对还是比较麻烦的，那么这里lambda就很好用了
	//sort(v.begin(), v.end(), ComparePriceLess());
	//sort(v.begin(), v.end(), ComparePriceGreater());
	// 20:08
	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
		return g1._price < g2._price;
		});

	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
		return g1._price > g2._price;
		});

	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
		return g1._evaluate < g2._evaluate;
		});

	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
		return g1._evaluate > g2._evaluate;
		});


	return 0;
}

4.4 lambda的原理

• lambda 的原理和范围for很像，编译后从汇编指令层的⻆度看，压根就没有 lambda 和范围for 这样的东西。范围for底层是迭代器，⽽lambda底层是仿函数对象，也就说我们写了⼀个
lambda 以后，编译器会⽣成⼀个对应的仿函数的类。 lambda的底层仿函数对象仿函数是由编译器自动生成，所以名称是由编译器取的(随机的，这也是我们无法写成lambda类型的原因无法取名)，怎么形成多个lambad对应多个的函数名=> vs系列是通过lambda+unid（一个不相同很多的字符串，重复概率极低)不同编译器实现原理可能不同，只有保证编译器生成的函数名是随机的即可。
• lambda表达式中的每个部分分别对应生成的底层仿函数中的那些部分：
仿函数的类名是编译按⼀定规则⽣成的，保证不同的 lambda ⽣成的类名不同，lambda参数/返 回类型/函数体就是仿函数operator()的参数/返回类型/函数体， lambda 的捕捉列表本质是⽣成 的仿函数类的成员变量，也就是说捕捉列表的变量都是 lambda 类构造函数的实参，当然隐式捕 捉，编译器要看使⽤哪些就传那些对象。

【示例】

class Rate
{
public:
	Rate(double rate)
		: _rate(rate)
	{
	}
	double operator()(double money, int year)
	{
		return money * _rate * year;
	}
private:
	double _rate;
};
int main()
{
	double rate = 0.49;
	// lambda
	auto r2 = [rate](double money, int year) {
		return money * rate * year;
		};
	// 函数对象
	Rate r1(rate);
	r1(10000, 2);
	r2(10000, 2);
	auto func1 = [] {
		cout << "hello world" << endl;
		};
	func1();
	return 0;
}

【汇编层解析】

五 包装器

5.1 function

5.1.1 function的语法/特点

• std::function 是⼀个类模板，也是⼀个包装器。 std::function 的实例对象可以包装存
储其他的可以调⽤对象，包括函数指针、仿函数、 lambda 、 bind 表达式等（这些可调用对象的参数和返回值必须相同)， 存储的可调⽤对象被称为 std::function 的 ⽬标 。若 std::function 不含⽬标，则称它为 空 。调⽤ 空 std::function 的 ⽬标 导致抛出 std::bad_function_call 异常。
• 以上是 function 的原型，他被定义<functional>头⽂件中。 std::function - cppreference.com
是function的官⽅⽂件链接。
• 函数指针、仿函数、 lambda 等可调⽤对象的类型各不相同， std::function 的优势就是统
⼀类型 [例如在容器中要插入相同类型，如果要插入一个函数和一个仿函数(参数相同返回值相同)此时是不可能实现的，当使用function将其转化为统一类型即可以了】 ，对他们都可以进⾏包装，这样在很多地⽅就⽅便声明可调⽤对象的类型。

5.1.2 function的定义

为什么可以包装各种各样的：其底层实现了很多个规则函数(空的，函数模板的)，传什么可调用对象就推出什么，在存起来，在调用operator()的时候底层由去调用存起来的对象(没用就会抛异常)

注意这里包装的要满足返回类型相同，参数相同，对于包装普通函数很简单，但是对于包装类的成员函数一定要记住还有一个隐形的参数this指针，所以包装类的成员函数，第一个参数一定是当前类

好处：

因为我们的容器要传相同类型的对象；那如果我们想传不同类型的对象可以使用function包装一下即可。

【示例】

#include<functional>
int f(int a, int b)
{
return a + b;
}
struct Functor
{
public:
int operator() (int a, int b)
{
return a + b;
}
};
class Plus
{
public:
Plus(int n = 10)
:_n(n)
{}
static int plusi(int a, int b)
{
return a + b;
}
double plusd(double a, double b)
{
return (a + b) * _n;
}
private:
int _n;
};
int main()
{
// 包装各种可调⽤对象
function<int(int, int)> f1 = f;
function<int(int, int)> f2 = Functor();
function<int(int, int)> f3 = [](int a, int b) {return a + b; };
cout << f1(1, 1) << endl;
cout << f2(1, 1) << endl;
cout << f3(1, 1) << endl;

// 包装静态成员函数
// 成员函数要指定类域并且前⾯加&才能获取地址
//静态成员函数可以不用为了统一还是加上，静态成员函数不用写this指针
function<int(int, int)> f4 = &Plus::plusi;
cout << f4(1, 1) << endl;

// 包装普通成员函数
// 注意普通成员函数还有⼀个隐含的this指针参数，所以绑定时传对象或者对象的指针过去都可以
function<double(Plus*, double, double)> f5 = &Plus::plusd;
Plus pd;
//三种传this指针的方式
cout << f5(&pd, 1.1, 1.1) << endl;
function<double(Plus, double, double)> f6 = &Plus::plusd;
cout << f6(pd, 1.1, 1.1) << endl;
cout << f6(pd, 1.1, 1.1) << endl;
function<double(Plus&&, double, double)> f7 = &Plus::plusd;
cout << f7(move(pd), 1.1, 1.1) << endl;
cout << f7(Plus(), 1.1, 1.1) << endl;
return 0;
}

5.1.3 function的应用

【题目】

逆波兰表达式求值

【传统写法】

// 传统⽅式的实现
class Solution {
public:
int evalRPN(vector<string>& tokens) {
stack<int> st;
for(auto& str : tokens)
{
if(str == "+" || str == "-" || str == "*" || str == "/")
{
int right = st.top();
st.pop();
int left = st.top();
st.pop();
switch(str[0])
{
case '+':
st.push(left+right);
break;
case '-':
st.push(left-right);
break;
case '*':
st.push(left*right);
break;
case '/':
st.push(left/right);
break;
}
}
else
{
st.push(stoi(str));
}
}
return st.top();
}
};

传统写法虽然可行，但是如果在增加一种运算符呢？就很麻烦。

【现代写法】
使⽤map映射string和function的⽅式实现
这种⽅式的最⼤优势之⼀是⽅便扩展，假设还有其他运算，我们增加map中的映射即可

// 使⽤map映射string和function的⽅式实现
// 这种⽅式的最⼤优势之⼀是⽅便扩展，假设还有其他运算，我们增加map中的映射即可
class Solution {
public:
int evalRPN(vector<string>& tokens) {
stack<int> st;
// function作为map的映射可调⽤对象的类型
map<string, function<int(int, int)>> opFuncMap = {
//增加一种运算符在这里增加即可
{"+", [](int x, int y){return x + y;}},
{"-", [](int x, int y){return x - y;}},
{"*", [](int x, int y){return x * y;}},
{"/", [](int x, int y){return x / y;}}
};
for(auto& str : tokens)
{
if(opFuncMap.count(str)) // 操作符
{
int right = st.top();
st.pop();
int left = st.top();
st.pop();
int ret = opFuncMap[str](left, right);
st.push(ret);
}
else
{
st.push(stoi(str));
}
}
return st.top();
}
};

5.2bind(绑定)

5.2.1bind的语法/特点

• bind 是⼀个函数模板，它也是⼀个可调⽤对象的包装器，可以把他看做⼀个函数适配器，对接收 的fn可调⽤对象进⾏处理后返回⼀个可调⽤对象。 bind 可以⽤来调整参数个数和参数顺序。 bind 也在<functional>这个头⽂件中。
• 调⽤bind的⼀般形式： auto newCallable = bind(callable,arg_list); 其中
newCallable本⾝是⼀个可调⽤对象，arg_list是⼀个逗号分隔的参数列表，对应给定的callable的参数。当我们调⽤newCallable时，newCallable会调⽤callable，并传给它arg_list中的参数。
• arg_list中的参数可能包含形如_n的名字，其中n是⼀个整数，这些参数是占位符，表⽰
newCallable的参数，它们占据了传递给newCallable的参数的位置。数值n表⽰⽣成的可调⽤对象中参数的位置：_1为newCallable的第⼀个参数，_2为第⼆个参数，以此类推。_1/_2/_3....这些占 位符放到placeholders的⼀个命名空间中(所以要使用占位符一定要指定命名空间)，记住不管_n占位符顺序然后，_1一定始终代表第一个参数)。
• 调整参数顺序：
例如使用占位符(_2,_1）代表传入的参数第一个参数代表实际中的第二个参数，二传入的第一个参数实际代表的是第一个参数。
• 调整参数个数：其中某个参数进行绑定，后面就要传这个参数了。

5.2.2bind和function的不同

function：由于统一类型，将多种类型包装在一层。

bind:用于调整参数顺序和参数个数，调整参数顺序传(a,b)和(b,a）不一样，调整参数个数，用于绑定某个参数就不用传了，常常用来调整参数个数，函数用来调整参数顺序。

5.2.3bind的示例

#include<functional>
using placeholders::_1;
using placeholders::_2;
using placeholders::_3;
int Sub(int a, int b)
{
return (a - b) * 10;
}
int SubX(int a, int b, int c)
{
return (a - b - c) * 10;
}
class Plus
{
public:
static int plusi(int a, int b)
{
return a + b;
}
double plusd(double a, double b)
{
return a + b;
}
};
int main()
{
auto sub1 = bind(Sub, _1, _2);
cout << sub1(10, 5) << endl;
// bind 本质返回的⼀个仿函数对象
// 调整参数顺序（不常⽤）
// _1代表第⼀个实参
// _2代表第⼆个实参
// ...
auto sub2 = bind(Sub, _2, _1);
cout << sub2(10, 5) << endl;
// 调整参数个数 （常⽤）
auto sub3 = bind(Sub, 100, _1);
cout << sub3(5) << endl;
auto sub4 = bind(Sub, _1, 100);
cout << sub4(5) << endl;
// 分别绑死第123个参数
auto sub5 = bind(SubX, 100, _1, _2);
cout << sub5(5, 1) << endl;
auto sub6 = bind(SubX, _1, 100, _2);
cout << sub6(5, 1) << endl;
auto sub7 = bind(SubX, _1, _2, 100);
cout << sub7(5, 1) << endl;

5.2.4bind的应用

前面我们讲过对于类的成员函数实现function要传第一个this指针参数，没次调用都要传对应的类类型，这里我们可以使用bind绑定第一个参数，后面就不用传第一个参数了。

class Plus
{
public:
Plus(int n = 10)
:_n(n)
{}
static int plusi(int a, int b)
{
return a + b;
}
double plusd(double a, double b)
{
return (a + b) * _n;
}
private:
int _n;
};
int main()
{
// 成员函数对象进⾏绑死，就不需要每次都传递了
function<double(Plus&&, double, double)> f6 = &Plus::plusd;
Plus pd;
cout << f6(move(pd), 1.1, 1.1) << endl;
cout << f6(Plus(), 1.1, 1.1) << endl

   return 0
}

本篇文章就到此结束，欢迎大家订阅我的专栏，欢迎大家指正，希望有所能帮到读者更好了解C++11知识 ，后面我将继续更新C++11相关知识。觉得有帮助的还请三联支持一下~后续会不断更新算法与数据结构相关知识，我们下期再见。