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必须返回或者到的对象，这样才能组成参数包给ArgumentsArguments(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 curprev->_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;
}