3. 可变参数模版
我们之前了解到模板的概念，让我们的代码中类和函数都可以模板化，从而支持多种不同类型。但是在C++98/03中，类模板和函数模板的参数只能是固定数量的，但是在C++11中，出现了可变模板参数，让模板参数能够接收不同数量的参数。
关于可变参数模板，这里只学习一些基本的特性，了解即可。想要深入了解的小伙伴可以自行查找资料。
3.1 可变参数模板的语法
对于可变参数，其实在我们刚开始学习C语言的时候就已经使用可变参数的函数了，对，就是printf函数
看到printf函数原型中用...表示可变参数，C++11也采用了类似的方法，我们看下面一个C++的可变参数的函数模板
template<class ...Args> void ShowList(Args... args) {}
注意：这里的Args是一个模板参数包，args是一个函数形参的参数包，这个参数包中可以包含0-N个参数
上面的参数args前面有省略号，所以它就是一个可变模版参数，我们把带省略号的参数称为“参数包”，它里面包含了0到N（N>=0）个模版参数。
获取参数包中参数个数的方式只有一种：使用sizeof关键字
这里有一个点需要注意：我们需要将代表参数包的
...放在sizeof的括号外面，不要思考这个用法的逻辑，当作新的语法记住就好。
但是这里有一个问题，我们无法直接获取参数包args中的每个参数的，只能通过展开参数包的方式来获取参数包中的每个参数，这是使用可变模版参数的一个主要特点，也是最大的难点，即如何展开可变模版参数。由于语法不支持使用args[i]这样方式获取可变参数，所以我们的用一些奇招来获取参数包的值。
3.2 递归函数方式展开参数包
这里我们主要利用的就是参数包里的参数个数可以是任意个，所以设计一个重载的函数用来当作递归的出口
//递归出口 template<class T> void ShowList(const T& t) { cout << t << endl; } //递归过程 template<class T, class ...Args> void ShowList(T value, Args... args) { cout << value << " "; ShowList(args...);//这里要使用...表示将参数包展开 } void Test10() { ShowList(1); ShowList(1, 'A'); ShowList(1, 'A', string("sort")); }
这里如果参数包里之后一个参数的话，就调用递归出口，如果大于一个参数，那么就会调用递归过程，然后将第一个参数识别给T，剩下的参数都放进从参数包中，递归调用。
3.3 逗号表达式展开参数包
template<class T> void PrintArgs(T t) { cout << t << " "; } template<class... Args> void ShowList(Args... args) { int arr[] = { (PrintArgs(args), 0)... }; cout << endl; } void Test10() { ShowList(1); ShowList(1, 'A'); ShowList(1, 'A', string("sort")); }
这种展开参数包的方式，不需要通过递归终止函数，是直接在expand函数体中展开的, PrintArg不是一个递归终止函数，只是一个处理参数包中每一个参数的函数。这种就地展开参数包的方式实现的关键是逗号表达式。我们知道逗号表达式会按顺序执行逗号前面的表达式。
expand函数中的逗号表达式：(printarg(args), 0)，也是按照这个执行顺序，先执行PrintArg(args)，再得到逗号表达式的结果0。
同时还用到了C++11的另外一个特性——初始化列表，通过初始化列表来初始化一个变长数组, {(printarg(args), 0)…}将会展开成((printarg(arg1),0),(printarg(arg2),0), (printarg(arg3),0), etc… )，最终会创建一个元素值都为0的数组int arr[sizeof…(Args)]。由于是逗号表达式，在创建数组的过程中会先执行逗号表达式前面的部分printarg(args)打印出参数，也就是说在构造int数组的过程中就将参数包展开了，这个数组的目的纯粹是为了在数组构造的过程展开参数包。
3.4 可变参数模板在STL中的应用——empalce相关接口函数
在增加了可变参数模板的语法之后，STL也增加了对应的接口，这里我们看一下vector中的emplace。
首先我们看到的emplace系列的接口，支持模板的可变参数，并且万能引用。那么相对insert和emplace系列接口的优势到底在哪里呢？
- 对于内置类型来说，emplace 接口和传统的插入接口在效率上是没有区别的，因为内置类型是直接插入的，不需要进行拷贝构造；
- 对于需要进行深拷贝的自定义类型来说，如果该类实现了移动构造，则 emplace 接口会比传统插入接口少一次浅拷贝，但总体效率差不多；如果该类没有实现移动构造，则 emplace 接口的插入效率要远高于传统插入接口；
- 这是因为在传统的插入接口中，需要先创建一个临时对象，然后将这个对象深拷贝或者移动拷贝到容器中，而 std::emplace() 则通过使用可变参数模板、万能模板等技术，直接在容器中构造对象，避免了对象的拷贝和移动；
- 对于不需要进行深拷贝的自定义类型来说，emplace 接口也会比传统插入接口少一次浅拷贝 (拷贝构造)，但总体效率也差不多；原因和上面一样，emplace 接口可以直接在容器中原地构造新的对象，避免了不必要的拷贝过程
在上一篇文中我们讲到，emplace 接口要比传统的插入接口高效，我们能使用 emplace 就不要使用传统插入接口，严格意义上说这种说法没有问题，但是并不是绝对的；因为 STL 中的容器都支持移动构造，所以 emplace 接口仅仅是少了一次浅拷贝而已，而浅拷贝的代价并不大；所以我们在使用 STL 容器时并不需要去刻意的使用 emplace 系列接口。
注意：上面的传统接口的移动构造和 emplace 接口的直接在容器中构造对象都只针对右值 (将亡值)，而对于左值，它都只能老实的进行深拷贝。
4. lambda表达式
在C++11之前，我们想要使用sort排序，使用sort，需要传仿函数用于规定比较的原则
可以看到，如果想要排序内置类型，可以使用仿函数greater/less，但是如果要排序自定义类型，就得自己写仿函数。特别是如果遇到同一个类按照不同方式排序的情况，就要去实现不同的类，特别是相同类的命名，给开发者带来了极大的不便，因此C++11中引进了Lambda表达式。
首先我们见一见什么叫lambda表达式
struct Goods { string _name; // 名字 double _price; // 价格 int _evaluate; // 评价 Goods(const char* str, double price, int evaluate) :_name(str) , _price(price) , _evaluate(evaluate) {} }; void Test12() { //这里想对存放的Goods对象按照不同的方式进行排序，就可以使用lambda表达式 vector<Goods> v = { {"apple",2.1,5},{"banana",3,4},{"orange",2.2,3}, {"pineapple",1.5,4 } }; sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) { return g1._name < g2._name; }); cout << "sort by name" << endl; for (auto& e : v) { cout << e._name << " " << e._price << " " << e._evaluate << endl; } cout << endl; sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) { return g1._price < g2._price; }); cout << "sort by price" << endl; for (const auto& e : v) { std::cout << e._name << " " << e._price << " " << e._evaluate << endl; } cout << endl; sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) { return g1._evaluate < g2._evaluate; }); cout << "sort by evaluate" << endl; for (const auto& e : v) { cout << e._name << " " << e._price << " " << e._evaluate << endl; } cout << endl; }
4.1 Lambda表达式的语法与用法
lambda表达式书写格式
[capture-list] (parameters) mutable -> return-type { statement}
表达式说明：
- [capture-list]：捕捉列表。出现在lambda函数的开始位置，编译器根据[]来判断接下来的代码是否是lambda表达式，因此此项不能省略，捕捉列表能够捕捉上下文中的变量共lambda表达式使用。
- (parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，可以连同()一起省略。
- mutable：默认情况下，lambda表达式（函数）总是一个const函数，mutable可以取消其常性。
- 注：使用此修饰符的时候，参数列表不可省略
- ->return-type：返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可以省略。返回值类型明确的情况下也可以省略，由编译器对返回类型进行推导。
- {statement}：函数体。在函数体内部，除了可以使用(parameters)中的函数参数外，还可以使用[capture-list]捕捉到的变量。
根据上述的语法格式，我们知道参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为空
void Test13() { // 最简单的lambda表达式，没有任何实际意义 [] {}; // 省略参数列表和返回值类型，返回值类型由编译器推导为int int a = 3, b = 4; [=] {return a + 3; }; // 省略了返回值类型，无返回值类型 auto fun1 = [&](int c) {b = a + c; };//由于lambda表达式的类型是编译器自动生成的，非常复杂，所有我们使用auto来定义 fun1(10); cout << a << " " << b << endl; // 各部分都很完善的lambda函数 auto fun2 = [=, &b](int c)->int {return b += a + c; }; cout << fun2(10) << endl; // 赋值捕捉x int x = 10; auto add_x = [x](int a) mutable { x *= 2; return a + x; }; cout << add_x(10) << endl; }
捕捉列表说明
捕捉列表描述了上下文中哪些数据可以被lambda使用，以及使用的方式传值还是传引用
- [var]：表示传值的方式捕捉变量var
- [=]：表示传值的方式捕捉所有父作用域的变量（包括this）
- [&var]：表示引用捕捉变量var
- [&]：表示引用捕捉所有父作用域的变量（包括this）
- [this]：标志值传递的方式捕捉当前的this指针
注意
- 父作用域指包含lambda函数的语句块
- 语法上捕捉列表可以由多个捕捉项组成，并以逗号分隔
- 例如：[=, &a, &b]：表示以引用传递的放啊是捕捉a和b，值传递方式捕捉其他所有变量
- [&, a, this]：值传递的方式捕捉a和this，引用方式捕捉其他所有变量
- 捕捉列表不允许变量重复传递，否则就会导致编译错误
- 在第2点上我们见到了[=, &a]这种用法，默认按照值传递的方式捕捉了所有的变量，但是把a单独拿出来说，意思将a单独处理，按照引用的方式传递。但是如果这里换成[=, a]，就出现了重复传递，会导致编译错误。
- 在块作用域以外的lambda函数捕捉列表必须为空
- 在块作用域中的lambda函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者非局部变量都会导致编译报错
- lambda表达式之间不能相互赋值，及时看起来类型相同
4.2 Lambda表达式的底层原理
实际上编译器在底层对lambda表达式的处理方式，是转换成函数对象（仿函数）再处理的。所谓仿函数，就是在类中重载了operator()运算符。我们看下面一段代码
class Add { public: Add(int base) :_base(base) {} int operator()(int num) { return _base + num; } private: int _base; }; void Test15() { int base = 1; //仿函数的调用方式 Add add1(base);//构造一个函数对象 cout << add1(10) << endl; //lambda表达式 auto add2 = [base](int num)->int { return base + num; }; cout << add2(10) << endl; }
这里定义了一个Add类，在其中进行了operator()的重载，然后实例化出了add1就可以叫做函数对象，可以像函数一样使用。然后定义了add2，这里将lambda表达式赋值给add2，此时add1和add2都可以像函数一样使用。
接下来我们看一下汇编的情况
我们首先看汇编语言中的1，可以看到在使用函数对象的时候，调用了Add中的operator()。
看2，这里是使用lambda表达式对add2进行赋值和调用，可以看到调用的同样也是operator()函数。值得注意的是这里调用的是<lambda_1>中的operator()，本质就是lambda表达式在底层被转换成了仿函数。
❓为什么我们不能显示的写lambda表达式的类型？
✅因为这个类型是由编译器自动生成的，我们没办法知道这个类名称的具体写法。
在VS下，生成的这类的类名叫做lambda_uuid，类名中的uuid叫做通用唯一识别码（Universally Unique Identifier），简单来说，uuid就是通过算法生成一串字符串，保证在当前程序当中每次生成的uuid都不会重复，这样就能保证每个lambda表达式底层类名都是唯一的。
(img-indD9wQt-1690376726287)]
4.2 Lambda表达式的底层原理
实际上编译器在底层对lambda表达式的处理方式，是转换成函数对象（仿函数）再处理的。所谓仿函数，就是在类中重载了operator()运算符。我们看下面一段代码
class Add { public: Add(int base) :_base(base) {} int operator()(int num) { return _base + num; } private: int _base; }; void Test15() { int base = 1; //仿函数的调用方式 Add add1(base);//构造一个函数对象 cout << add1(10) << endl; //lambda表达式 auto add2 = [base](int num)->int { return base + num; }; cout << add2(10) << endl; }
这里定义了一个Add类，在其中进行了operator()的重载，然后实例化出了add1就可以叫做函数对象，可以像函数一样使用。然后定义了add2，这里将lambda表达式赋值给add2，此时add1和add2都可以像函数一样使用。
接下来我们看一下汇编的情况
[外链图片转存中…(img-LEIRNSC7-1690376726288)]
我们首先看汇编语言中的1，可以看到在使用函数对象的时候，调用了Add中的operator()。
看2，这里是使用lambda表达式对add2进行赋值和调用，可以看到调用的同样也是operator()函数。值得注意的是这里调用的是<lambda_1>中的operator()，本质就是lambda表达式在底层被转换成了仿函数。
❓为什么我们不能显示的写lambda表达式的类型？
✅因为这个类型是由编译器自动生成的，我们没办法知道这个类名称的具体写法。
在VS下，生成的这类的类名叫做lambda_uuid，类名中的uuid叫做通用唯一识别码（Universally Unique Identifier），简单来说，uuid就是通过算法生成一串字符串，保证在当前程序当中每次生成的uuid都不会重复，这样就能保证每个lambda表达式底层类名都是唯一的。
本节完 …
