C++11（二）

可变参数模板

基本语法及原理

• C++11支持可变参数模板，也就是说支持可变数量参数的函数模板和类模板，可变数目的参数被称为参数包，存在两种参数包：1、模板参数包，表示零个或多个模板参数；2、函数参数包：表示零个或多个函数参数。
• 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...运算符去计算参数包中参数的个数。

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个参数
	return 0;
}

 包扩展

• 对于一个参数包，我们除了能计算它的参数个数，我们能做的唯一事情就是扩展它。当扩展一个包时，我们还要提供用于每个扩展元素的模式，扩展一个包就是将它分解为构成的元素，对每个元素应用模式，获得扩展后的列表。我们通过在模式的右边放一个省略号(...)来触发扩展操作。底层实现细节如图1所示。
• C++11还支持更复杂的包扩展，直接将参数包展开依次作为实参给一个函数去处理。由于可变参数模板传参实例化生成的函数无法使用循环打印参数值，因此只能通过递归形式逐个参数递归打印。

图1 

//可变参数模板的参数类型可变，参数个数可变
// 
//打印参数包内容
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;
}
/*********************************************************/
//正确用法：包扩展的递归推导
void ShowList()
{
	//编译器推导时递归的终止条件
	cout << endl;
}

template<class T, class ...Args>
void ShowList(class T, Args... args)
{
	cout << x << " ";
	//args是N个参数的参数包
	//调用ShowList，参数包的第一个传给x，剩下N-1传给第二个参数包。
	ShowList(args...);
}

//编译时递归推导解析参数
template<class ...Args>
void Print(Args... args)
{
	ShowList(args...);
}
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;
}

另一种写法：

//写成const模板是因为，const引用类型既可以接收左值，又可以接收右值
template<class T>
const T& GetArg(const T& x)
{
	cout << x << " ";
	return x;
}

template<class ...Args>
void Arguments(Args... args)
{}

template<class ...Args>
void Print(Args... args)
{
	//注意GetArg必须返回获得到的对象，这样才能组成参数包给Argument
	Arguments(GetArg(args)...);
}
// 本质可以理解为编译器编译时，包的扩展模式
// 将上⾯的函数模板扩展实例化为下⾯的函数
// 是不是很抽象，C++11以后，只能说委员会的⼤佬设计语法思维跳跃得太厉害
//void Print(int x, string y, double z)
//{
//     Arguments(GetArg(x), GetArg(y), GetArg(z));
//}
int main()
{
	Print(1, string("xxxxx"), 2.2);
	return 0;
}

emplace系列接口

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

// emplace_back总体⽽⾔是更⾼效，推荐以后使⽤emplace系列替代insert和push系列
int main()
{
	list<zy::string> lt;
	// 传左值，跟push_back⼀样，⾛拷⻉构造
	zy::string s1("111111111111");
	lt.emplace_back(s1);
	cout << "*********************************" << endl;
	// 右值，跟push_back⼀样，⾛移动构造
	lt.emplace_back(move(s1));
	cout << "*********************************" << endl;
	// 直接把构造string参数包往下传，直接⽤string参数包构造string
	// 这⾥达到的效果是push_back做不到的
	lt.emplace_back("111111111111");
	cout << "*********************************" << endl;
	list<pair<zy::string, int>> lt1;
	// 跟push_back⼀样
	// 构造pair + 拷⻉/移动构造pair到list的节点中data上
	pair<zy::string, int> kv("苹果", 1);
	lt1.emplace_back(kv);
	cout << "*********************************" << endl;
	// 跟push_back⼀样
	lt1.emplace_back(move(kv));
	cout << "*********************************" << endl;
	
	// 直接把构造pair参数包往下传，直接⽤pair参数包构造pair
	// 这⾥达到的效果是push_back做不到的
	lt1.emplace_back("苹果", 1);
	cout << "*********************************" << endl;
	return 0;
}

// List.h
namespace zy
{
	template<class T>
	struct ListNode
	{
		ListNode<T>* _next;
		ListNode<T>* _prev;
		T _data;
		ListNode(T&& data)
			:_next(nullptr)
			, _prev(nullptr)
			, _data(move(data))
		{}
		template <class... Args>
		ListNode(Args&&... args)
			: _next(nullptr)
			, _prev(nullptr)
			, _data(std::forward<Args>(args)...)
		{}
	};
	template<class T, class Ref, class Ptr>
	struct ListIterator
	{
		typedef ListNode<T> Node;
		typedef ListIterator<T, Ref, Ptr> Self;
		Node* _node;
		ListIterator(Node* node)
			:_node(node)
		{}
		// ++it;
		Self& operator++()
		{
			_node = _node->_next;
			return *this;
		} 
		Self& operator--()
		{
			_node = _node->_prev;
			return *this;
		} 
		Ref operator*()
		{
			return _node->_data;
		} 
		bool operator!=(const Self& it)
		{
			return _node != it._node;
		}
	};
	template<class T>
	class list
	{
		typedef ListNode<T> Node;
	public:
		typedef ListIterator<T, T&, T*> iterator;
		typedef ListIterator<T, const T&, const T*> const_iterator;
		iterator begin()
		{
			return iterator(_head->_next);
		} 
		iterator end()
		{
			return iterator(_head);
		} 
		void empty_init()
		{
			_head = new Node();
			_head->_next = _head;
			_head->_prev = _head;
		} 
		list()
		{
			empty_init();
		} 
		void push_back(const T& x)
		{
			insert(end(), x);
		} 
		void push_back(T&& x)
		{
			insert(end(), move(x));
		}
		iterator insert(iterator pos, const T& x)
		{
			Node* cur = pos._node;
			Node* newnode = new Node(x);
			Node* prev = cur->_prev;
			// prev newnode cur
			prev->_next = newnode;
			newnode->_prev = prev;
			newnode->_next = cur;
			cur->_prev = newnode;
			return iterator(newnode);
		} 
		iterator insert(iterator pos, T&& x)
		{
			Node* cur = pos._node;
			Node* newnode = new Node(move(x));
			Node* prev = cur->_prev;
			// prev newnode cur
			prev->_next = newnode;
			newnode->_prev = prev;
			newnode->_next = cur;
			cur->_prev = newnode;
			return iterator(newnode);
		} 
		template <class... Args>
		void emplace_back(Args&&... args)
		{
			insert(end(), std::forward<Args>(args)...);
		} 
		// 原理：本质编译器根据可变参数模板⽣成对应参数的函数
			/*void emplace_back(string& s)
			{
				insert(end(), std::forward<string>(s));
			}
			void emplace_back(string&& s)
			{
				insert(end(), std::forward<string>(s));
			}
			void emplace_back(const char* s)
			{
				insert(end(), std::forward<const char*>(s));
			} */ 
			template <class... Args>
			iterator insert(iterator pos, Args&&... args)
			{
				Node* cur = pos._node;
				Node* newnode = new Node(std::forward<Args>(args)...);
				Node* prev = cur->_prev;
				// prev newnode cur
				prev->_next = newnode;
				newnode->_prev = prev;
				newnode->_next = cur;
				cur->_prev = newnode;
				return iterator(newnode);
			}
	private:
		Node* _head;
	};
}

// Test.cpp
#include"List.h"
// emplace_back总体⽽⾔是更⾼效，推荐以后使⽤emplace系列替代insert和push系列
int main()
{
	zy::list<zy::string> lt;
	// 传左值，跟push_back⼀样，⾛拷⻉构造
	zy::string s1("111111111111");
	lt.emplace_back(s1);
	cout << "*********************************" << endl;
	// 右值，跟push_back⼀样，⾛移动构造
	lt.emplace_back(move(s1));
	cout << "*********************************" << endl;
	// 直接把构造string参数包往下传，直接⽤string参数包构造string
	// 这⾥达到的效果是push_back做不到的
	lt.emplace_back("111111111111");
	cout << "*********************************" << endl;
	zy::list<pair<zy::string, int>> lt1;
	// 跟push_back⼀样
	// 构造pair + 拷⻉/移动构造pair到list的节点中data上
	pair<zy::string, int> kv("苹果", 1);
	lt1.emplace_back(kv);
	cout << "*********************************" << endl;
	// 跟push_back⼀样
	lt1.emplace_back(move(kv));
	cout << "*********************************" << endl;
	
	// 直接把构造pair参数包往下传，直接⽤pair参数包构造pair
	// 这⾥达到的效果是push_back做不到的
	lt1.emplace_back("苹果", 1);
	cout << "*********************************" << endl;
	return 0;
}

 C++11-新的类功能

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

• 原来C++类中，有6个默认成员函数：构造函数/析构函数/拷贝构造函数/拷贝赋值重载/取地址运算符重载，最重要的是前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:
	zy::string _name;
	int _age;
};
int main()
{
	Person s1;
	Person s2 = s1;
	Person s3 = std::move(s1);
	Person s4;
	s4 = std::move(s2);
	return 0;
}

 成员变量声明时给缺省值

        成员变量声明时给缺省值是给初始化列表用的，如果没有在初始化列表中显式初始化，就会使用声明时给的缺省值初始化，这个我们在类和对象部分讲过，忘记了的可以去复习一下。

default和delete

• C++11可以让你更好的控制要使用的默认函数。假设你要是用某个默认的成员函数，但是因为一些原因这个函数没有默认生成。比如：我们提供了拷贝构造，就不会生成移动构造了，那么我们可以使用default关键字显式指定移动构造生成。
• 如果想要限制某些默认函数的生成，在c++98中，可以将该函数设置成private，并且只声明不定义，这样只要其他人想要调用就会报错；在C++11中更加简单，只需在该函数声明上给与delete缺省值就可以。该语法指示编译器不生成对应函数的默认版本，称初始化为delete的默认函数为删除函数。

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(Person&& p) = default;
	//Person(const Person& p) = delete;
private:
	zy::string _name;
	int _age;
};
int main()
{
	Person s1;
	Person s2 = s1;
	Person s3 = std::move(s1);
	return 0;
}

final与override

这个我们在继承与多态章节已经进行了详细讲解，忘记了的可以去复习一下。

C++11后STL中的一些变化

• 下图圈起来的就是STL中的新容器，但是最实际最有用的是unordered_map 和 unordered_set。这两个我们前面已经进行了非常详细的讲解，其他的大家了解即可。
• STL容器的新接口也不少，最重要的就是右值引用和移动语义相关的push/insert/emplace系列接口和移动构造的移动赋值，还有initializer_list版本的构造等，这些前面都讲过了，还有一些无关紧要的如cbegin/cend等需要时自行查阅文档即可。
• 容器的范围for遍历，这个在STL容器部分已经讲过了。 

lambda表达式

语法

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

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;
}

捕捉列表

• lambda表达式中默认只能用lambda函数体和参数中的变量，如果想用外层作用域中的变量就需要进行捕捉。
• 第一种捕捉方式是在捕捉列表中显示的传值捕捉和传引用捕捉，捕捉的多个变量之间用逗号分隔。例如：[ x, y, &z] 表示的是x和y是值捕捉，z是引用捕捉。
• 第二种捕捉方式是在捕捉列表中隐式捕捉，我们在捕捉列表写一个 = 表示隐式值捕捉类型，在捕捉列表写一个 & 表示引用捕捉类型，这样我们lambda表达式中用了哪些变量，编译器就会自动捕捉哪些变量。
• 第三种捕捉方式是在捕捉列表中混合使用隐式捕捉和显示捕捉。例如：[ =, &x ]表示除x外的其他变量为隐式值捕捉，x为引用捕捉；[ &, x, y ]表示除了x和y是值捕捉之外，其他使用到的变量均为隐式引用捕捉。当我们使用混合捕捉时，第一个元素必须是 &或=，并且&混合捕捉时后面的捕捉只能是值捕捉，同理，=混合捕捉时后面的捕捉变量只能时引用捕捉。
• lambda表达式如果在函数局部域中，它可以捕捉lambda位置之前定义的变量，不能捕捉静态局部变量和全局变量，静态局部变量和全局变量也不需要捕捉，lambda表达式中可以直接使用。这也意味着如果lambda表达式如果定义在全局域，捕捉列表必须为空。
• 默认情况下，lambda捕捉列表是被const修饰的，也就是说传值捕捉的对象不能修改，但可以使用mutable加在参数列表的后面可以取消其常量性，也就是说使用该修饰符后，传值捕捉的对象就可以修改了，但是修改的是形参，不会影响实参。使用该修饰符后参数列表不可省略（即使参数为空）。

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;
	// 混合捕捉1
	auto func4 = [&, a, b]
		{
			//a++;
			//b++;
			c++;
			d++;
			return a + b + c + d;
		};
	func4();
	cout << a << " " << b << " " << c << " " << d << endl;
	// 混合捕捉2
	auto func5 = [=, &a, &b]
		{
			a++;
			b++;
			/*c++;
			d++;*/
			return a + b + c + d;
		};
	func5();
	cout << a << " " << b << " " << c << " " << d << endl;
	// 局部的静态和全局变量不能捕捉，也不需要捕捉
	static int m = 0;
	auto func6 = []
		{
			int ret = x + m;
			return ret;
		};
	// 传值捕捉本质是⼀种拷⻉,并且被const修饰了
	// mutable相当于去掉const属性，可以修改了
	// 但是修改了不会影响外⾯被捕捉的值，因为是⼀种拷⻉
	auto func7 = [=]()mutable
		{
			a++;
			b++;
			c++;
			d++;
			return a + b + c + d;
		};
	cout << func7() << endl;
	cout << a << " " << b << " " << c << " " << d << endl;
	return 0;
}

 lambda的应用

• 在学习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());

	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;
}

lambda的原理

• lambda的原理和范围for很像，编译后从汇编指令的角度看，压根就没有lambda和范围for这样的东西。范围for底层是迭代器，而lambda底层是仿函数对象，也就是说我们写了一个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
    // 捕捉列表的rate，可以看作为lambda_1类构造函数的参数传递了，这样要拿去初始化成员变量
	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;
}

• 上面的原理，我们可以透过汇编层了解一下，下面第二段汇编层代码印证了上面的原理。

// 下⾯operator()中才能使⽤
00D8295C lea eax,[rate]
00D8295F push eax
00D82960 lea ecx,[r2]
00D82963 call `main'::`2'::<lambda_1>::<lambda_1> (0D81F80h)
// 函数对象
Rate r1(rate);
00D82968 sub esp,8
00D8296B movsd xmm0,mmword ptr [rate]
00D82970 movsd mmword ptr [esp],xmm0
00D82975 lea ecx,[r1]
00D82978 call Rate::Rate (0D81438h)
r1(10000, 2);
00D8297D push 2
00D8297F sub esp,8
00D82982 movsd xmm0,mmword ptr [__real@40c3880000000000 (0D89B50h)]
00D8298A movsd mmword ptr [esp],xmm0
00D8298F lea ecx,[r1]
00D82992 call Rate::operator() (0D81212h)
// 汇编层可以看到r2 lambda对象调⽤本质还是调⽤operator()，类型是lambda_1,这个类型名
// 的规则是编译器⾃⼰定制的，保证不同的lambda不冲突
r2(10000, 2);
00D82999 push 2
00D8299B sub esp,8
00D8299E movsd xmm0,mmword ptr [__real@40c3880000000000 (0D89B50h)]
00D829A6 movsd mmword ptr [esp],xmm0
00D829AB lea ecx,[r2]
00D829AE call `main'::`2'::<lambda_1>::operator() (0D824C0h)

包装器

function

template <class T>
class function; // undefined

template <class Ret, class... Args>
class function<Ret(Args...)>;

• 上面是function的原型，它被定义在<functional>头文件中。std::function -官方文档
• std::function 是一个类模板，也是一个包装器。std::function 的实例对象可以包装存储其他的可调用对象，包括函数指针、仿函数、lambda、bind表达式等，存储的可调用对象被称为std::function 的目标。若 std::function 不含目标，则称它为空。调用空std::function的目标导致抛出 std::bad_function_call 异常。
• 函数指针、仿函数、lambda等可调用对象的类型各不相同，std::function的优势就是统一类型，对他们都可以进行包装，这样在很多地方就方便声明可调用对象的类型，下面习题的第二个代码样例展示了std::function作为map的参数，实现字符串和可调用对象的映射表功能。

#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;

	// 包装静态成员函数
	// 所有成员函数都要指定类域并且前⾯加&才能获取地址
	function<int(int, int)> f4 = &Plus::plusi;
	cout << f4(1, 1) << endl;

	Plus pd;
	// 包装普通成员函数
	// 普通成员函数还有⼀个隐含的this指针参数，所以绑定时传对象或者对象的指针过去都可以
	function<double(Plus*, double, double)> f5 = &Plus::plusd;
	cout << f5(&pd, 1.1, 1.1) << endl;
	function<double(Plus, double, double)> f6 = &Plus::plusd;
	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;
}

 习题

150. 逆波兰表达式求值 - 力扣（LeetCode）

// 传统⽅式的实现
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中的映射即可
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();
	}
};

bind

simple(1)
template <class Fn, class... Args>
/* unspecified */ bind (Fn&& fn, Args&&... args);
with return type (2)
template <class Ret, class Fn, class... Args>
/* unspecified */ bind (Fn&& fn, Args&&... args);

• 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为newCallable的第二个参数，以此类推。这些占位符都被放在一个名为placeholders的命名空间中。

#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;

	// 对成员函数对象进⾏绑死，就不需要每次都传递了
	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;

	// bind⼀般⽤于，绑死⼀些固定参数
	function<double(double, double)> f7 = bind(&Plus::plusd, Plus(), _1, _2);
	cout << f7(1.1, 1.1) << endl;

	// 计算复利的lambda
	auto func1 = [](double rate, double money, int year)->double {
		    double ret = money;
		    for (int i = 0; i < year; i++)
		    {
		    	ret += ret * rate;
		    } 
		    return ret - money;
		};

	// 绑死⼀些参数，实现出⽀持不同年华利率，不同⾦额和不同年份计算出复利的结算利息
	function<double(double)> func3_1_5 = bind(func1, 0.015, _1, 3);
	function<double(double)> func5_1_5 = bind(func1, 0.015, _1, 5);
	function<double(double)> func10_2_5 = bind(func1, 0.025, _1, 10);
	function<double(double)> func20_3_5 = bind(func1, 0.035, _1, 30);
	cout << func3_1_5(1000000) << endl;
	cout << func5_1_5(1000000) << endl;
	cout << func10_2_5(1000000) << endl;
	cout << func20_3_5(1000000) << endl;
	return 0;
}

智能指针

下期讲解~