C++11详解(三) -- 可变参数模版和lambda

1.可变模版参数

1.1 基本语法及其原理

1. C++11支持可变参数模版，也就是说支持可变数量参数的函数模版和类模版，可变数目的参数为参数包，存在两种参数包：模板参数包，表示零或多个模板参数；函数参数包：表示零或多个函数参数。
2. 用省略号来指出一个模板参数或函数参数的表示一个包，在模板参数列表中，class…或typename…指出接下来的参数表示零或多个类型列表；
在函数参数列表中，类型名后面跟…指出接下来表示零或多个形参对象列表；
函数参数包可以用左值引用或右值引用表示，跟前面普通模板一样，每个参数实例化时遵循引用折叠规则。
3. 可变参数模板的原理跟模板类似，本质还是去实例化对应类型和个数的多个函数。
4. 可变模版参数：参数类型可变，参数个数可变

…Args：模版参数包
…args：函数参数包

// 0-N个参数
// ...:表示多个参数
template<class ...Args>
void Print(Args&& ... args)
{
    // sizeof...是一个新的运算符
	// sizeof... 计算参数包里面有几个参数
	cout << sizeof...(args) << endl;
}

int main()
{
	Print(); // 0个参数
	Print(1);// 1个参数
	Print(1, 2.2);// 2个参数

	return 0;
}

• 可变模版参数：本质上是模版的模版，可变模版参数实例化出对应的各个模版，这些模版再实例化出对应的类或者是函数

• 总结：模版，一个函数模版可以实例化出多个不同类型参数的函数，可变参数模版，一个可变参数模版函数可以实例化出多个不同参数个数的模版函数
• 主要就是一个可变参数模版实例化出多个函数模版，函数模版再实例化多个函数

1.2 包扩展

1. 包扩展：解析出参数包的内容
2. 编译时递归包括展，其实也不是递归，因为每次都生成不同的函数重载，只是每次用自己这个函数进行传参（包扩展）

参数包的第一种扩展方式(编译时递归)：

// 打印参数包内容
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()
{
	// 编译器递归终止的条件,参数包是0个时,直接匹配这个函数
	cout << endl;
}

template<class T,class ...Args>
void ShowList(T x, Args ...args)
{
    // 运行时
    /*if (sizeof...(args) == 0)
	return;*/
	
	cout << x << " ";
	// args是N个参数的参数包,一个参数传给x,剩下的N-1个参数
	// 传给args,继续往下递归
	ShowList(args...);
}

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

int main()
{
	Print();
	Print(1);
	Print(1, string("xxxxxx"));
	Print(1,string("xxx"),2.2);

	return 0;
}

模版写给编译器，让编译器生成对应的包括展

第二种扩展方式(通过函数调用)：

// 下面两个GetArg都可以用
// 可以随便返回任何数
template<class T>
int GetArg(const T& x)
{
	cout << x << " ";
	return 0;
}

//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必须返回或者到的对象，这样才能组成参数包给Arguments
	Arguments(GetArg(args)...);
	有几个参数调用几次Arguments
}

// 实际上就是下面这段
// 本质可以理解为编译器编译时，包的扩展模式
// 将上⾯的函数模板扩展实例化为下⾯的函数
//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;
}

1.3 empalce系列接口

1.3.1 push_back和emplace_back

1. 传左值：都会走拷贝构造
   
2. 传右值：都走移动构造
   
3. 对于深拷贝：
   直接传参，push_back,类模版实例化出string,会构造临时对象+移动构造
   emplace_back，会直接用const char* 构造
   所以emplace_back会稍微快一点
   对于浅拷贝：
   比如Date,字节大小不大，push_back变为构造 + 拷贝构造，emplace_back还是直接构造
   
   多参数的：
4. 对于pair键值对，It1.emplace_back({“苹果”，1})是不支持的，因为emplace_back支持传多个参数类型，而不知道你传的是键值对pair
   

1.3.2 emplace_back在list中的使用（模拟实现）

其实并不都是要像Print中解析包扩展，这样往下传即可

// 初始化列表
list_node() = default;

template <class... Args>
list_node(Args&&... args)
		: _next(nullptr)
		, _prev(nullptr)
		, _data(std::forward<Args>(args)...)
	    {}

// emplace_back()
template <class... Args>
void emplace_back(Args&&... args)
{
	insert(end(), std::forward<Args>(args)...);
}

// insert()
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);
}

2. lambda

2.1 lambda表达式语法

1. lambda 表达式本质是一个匿名函数对象，跟普通函数不同的是他可以定义在函数内部,也可以写在全局，lambda 表达式语法使用层而言没有类型，所以我们一般是用auto或者模板参数定义的对象去接收 lambda 对象。
2.lambda表达式的格式：
[捕捉列表]（参数列表）->返回值类型{函数体}
3. lambda可以传给模版的参数，也可以传给auto，让auto自动推导

#include<algorithm>

struct Goods
{
	string _name; // 名字
	double _price; // 价格
	int _evaluate; // 评价
	// ...
	Goods(const char* str, double price, int evaluate)
		:_name(str)
		, _price(price)
		, _evaluate(evaluate)
	{}
};

// 仿函数,价格升序
struct Compare1
{
	bool operator()(const Goods& gl, const Goods& gr)
	{
		return gl._price < gr._price;
	}
};

// 价格降序
struct Compare2
{
	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(), Compare1());
	// sort(v.begin(), v.end(), Compare2());

	// 写法二
	// 用 lambda就可以用匿名函数对象比较多种数据,不用写专门的仿函数单独比较一项了
	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;});
	// [](const Goods& g1, const Goods& g2) {return g1._evaluate > g2._evaluate; }
	// 匿名的函数对象

	return 0;
}

2.2 lambda的捕捉列表

1. lambda 表达式中默认只能用 lambda 函数体和参数中的变量，如果想用外层作用域中的变量就需要进行捕捉
2. 第⼀种捕捉方式是在捕捉列表中显示的传值捕捉和传引用捕捉，捕捉的多个变量用逗号分割。[x，y， &z] 表示x和y传值捕捉，z引用捕捉。
3. lambda支持的是轻量级的

int y = 0;

// lambda可以写在全局
auto func2 = []()
{
	y++;
};

int main()
{
	int a = 0, b = 1, c = 2, d = 3;
	// 可以用lambda局部域,捕捉对象和全局对象
	auto func1 = [a, &b]
	{
	    // 传值捕捉,捕捉过来的是被const修饰的,不能修改
		// 引用捕捉可以修改
		// a++;
		b++;
		int ret = a + b + y;
		// 可以直接使用全局域的东西
		return ret;
	};

	cout << func1() << endl;
	func2();

	return 0;
}

3. 第二种捕捉方式叫隐式捕捉(全部捕捉)：我们在捕捉列表写一个=表示隐式值捕捉，在捕捉列表写一个&表示隐式引用捕捉

// 隐式值捕捉
auto func3 = [=]
{
	int ret = a + b + c;
	return ret;
};
cout << func3() << endl;
// 匿名函数对象 + ()是调用函数

// 隐式引用捕捉
auto func4 = [&]
{
	a++;
	b++;
	c++;
};
func4();
cout << a << ":" << b << ":" << c << endl;

4. 混合捕捉：

1. 有些传值捕捉，其他引用捕捉
2. 有些引用捕捉，其他传值捕捉

混合捕捉,有些传值捕捉,其他引用捕捉
auto func5 = [&, a, b]
{
	// a++;
	// b++;
	c++;
	d++;

	return a + b + c + d;
};
func5();
cout << a << " " << b << " " << c << " " << d << endl;

 混合捕捉,有些传引用捕捉,其他传值捕捉
auto func6 = [=, &a, &b]
{
	a++;
	b++;

	return a + b + c;
};
func6();
cout << a << " " << b << " " << c << endl;

5. 局部的静态和全局不用捕捉，也不能捕捉，直接可以使用

static int t = 0;
// 局部的静态和全局变量不用捕捉直接使用
auto func7 = []
{
	int ret = t + y;
	return ret;
};

6. 默认传值捕捉是被const修饰的，但是在参数列表后面加mutable可以取消它的const属性，还有就是在lambda体内是可以修改它了，到外面它的值是不变的

int f = 0;
auto func8 = [=]()mutable
{
	a++;
	b++;
	c++;
	f++;
	
	return a + b + c + f;
};

f++后到外面值不变，还是传值捕捉

2.3 lambda的原理

1. lambda 的原理和范围for很像，编译后从汇编指令层的角度看，压根就没有 lambda 和范围for
这样的东西。范围for底层是迭代器，而lambda底层是仿函数对象，也就说我们写了一个lambda 以后，编译器会生成一个对应的仿函数的类
2. 仿函数的类名是编译按一定规则生成的，保证不同的 lambda 生成的类名不同，lambda参数/返回类型/函数体就是仿函数operator()的参数/返回类型/函数体， lambda 的捕捉列表本质是生成的仿函数类的成员变量，也就是说捕捉列表的变量都是 lambda 类构造函数的实参，当然隐式捕捉，编译器要看使用哪些就传哪些对象（用谁就捕捉谁，并不是全部都捕捉）