【C++、C++11】可变参数模板、lambda表达式、包装器

📖 前言

上一篇我们已经将C++11开了个头，详细讲述了C++11中的 { } 列表初始化和右值引用，本章将继续讲解C++11中的一些新的且比较实用的功能。

列表初始化 + 右值引用复习：👉 传送门

---

1. 可变参数模板

C++11的新特性可变参数模板：

• 能够让创建可以接受可变参数的函数模板和类模板，相比C++98 / C++03
• 类模版和函数模版中只能含固定数量的模版参数，可变模版参数无疑是一个巨大的改进
• 然而由于可变模版参数比较抽象，使用起来需要一定的技巧，所以这块还是比较晦涩的

1.1 万能模板：

万能模板的有样式：

• 模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值
• 模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力
• 但是引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值

很显然这并不是我们想要的，因为无论传的是左值还是右值，都将退化成左值：

void Fun(int& x) { cout << "左值引用" << endl; }
void Fun(const int& x) { cout << "const 左值引用" << endl; }void Fun(int&& x) { cout << "右值引用" << endl; }
void Fun(const int&& x) { cout << "const 右值引用" << endl; }//std::forward<T>(t)在传参的过程中保持了t的原生类型属性。template<typename T>
void PerfectForward(T&& t)
{//完美转发，按照原封不动的方式进行转发//Fun(t);Fun(std::forward<T>(t));
}int main()
{PerfectForward(10);           //右值int a;PerfectForward(a);            //左值PerfectForward(std::move(a)); //右值const int b = 8;PerfectForward(b);		      //const 左值PerfectForward(std::move(b)); //const 右值return 0;
}

如图所示全部都是调用左值引用了，这可能是编译器底层实现的原因，但是这显然不是一个好的现象。

---

1.2 完美转发：

我们希望能够在传递过程中保持它的左值或者右值的属性, 就需要用我们下面学习的

完美转发：


C++11新提供的forward函数模板，可以解决上述问题，使得传右值不会退化成左值，。

---

1.3 可变参数模板的使用：

首先在学C语言的时候，我们用的printf函数是一个可变参数函数，printf从语法上说是可以写多个参数，然后该函数自己识别。

可变参数模板：

解释：

• 可变模板参数，源自于printf（可变参数函数），…代表可变参数
• Args是一个模板参数包，args是一个函数形参参数包
• 声明一个参数包Args…args，这个参数包中可以包含0到任意个模板参数

模板的可变类型参数，不仅不知道有多少个，还不知道类型，要推演出来。

template <class ...Args>
void ShowList1(Args... args)
{//参数个数cout << sizeof...(args) << endl;
}//不一定非要用Args也可以取别的名字
template <class ...X>
void ShowList2(X... y)
{cout << sizeof...(y) << endl;
}int main()
{ShowList1(1, 'x', 1.1);ShowList2(1, 2, 3, 4, 5);return 0;
}

运行结果是：3 5

参数包展开：

//方法一：//递归到最后一个，就找最匹配的那一个
template <class T>
void ShowList(const T& val)
{cout << val << "->" << typeid(val).name() << "end" << endl;
}//编译时递归去推
//整个推导的过程是在编译的时候进行的（这是个编译的过程 -- 编译时决议）
template <class T, class ...Args>
void ShowList(const T& val, Args... args)
{cout << sizeof...(args) << endl;cout << val << "->" << typeid(val).name() << endl;//去递归解析ShowList(args...);
}//方法二：//0个模板参数走这个 -- 作为递归的终结
void ShowList()
{}int main()
{ShowList(1, 'x', 1.1);cout << endl;//有几个参数都能推ShowList(1, 2, 3, 4, 5);return 0;
}

• 类似于递归的一个过程，但是不是递归，最后都有一个结束条件，参数包中的模板参数是一个一个减少的。
• 整个推导的过程是在编译的时候进行的（这是个编译的过程 – 编译时决议）

用参数包定义数组：

template <class ...Args>
void ShowList(Args... args)
{//*列表初始化 -- 这种方法不通用//C++只允许数组里面是同一个类型的int arr[] = { args... };cout << endl;
}int main()
{//ShowList(1, 'x', 1.1, vector<int>{2, 2});这种就不适用 -》 int arr[] = { args... };//cout << endl;ShowList(1, 2, 3, 4, 5);ShowList(10, 20, 30);return 0;
}

template <class T>
int PrintArg(const T& t)
{cout << t << " ";return 0;
}template <class ...Args>
void ShowList(Args... args)
{//列表初始化//int arr[] = { (PrintArg(args), 0)...};int arr[] = { PrintArg(args)... };cout << endl;
}int main()
{ShowList(1, 'x', 1.1, string("hello world"));cout << endl;ShowList(1, 2, 3, 4, 5);//ShowList(10, 20, 30);return 0;

---

1.4 emplace_back：

C++11STL中新增了一个尾插的方法：

• emplace_back支持可变参数，拿到构建pair对象的参数后自己去创建对象
• 那么在这里我们可以看到除了用法上，和push_back没什么太大的区别
• 可以不传pair，可以直接传参数
• 拿到参数自己构建对象（保证了底层一定是右值 —— 直接去构造的）

push_back()：

• 参数如果给的是左值是：构造 + 拷贝构造
• 参数如果给的是右值是：构造 + 移动构造
• 函数传值返回也是个右值

emplace_back()：

• 直接构造

这两者其实差距不大

2. lambda表达式

在仿函数那一节我们知道，如果我们用每次为了实现一个sort算法，因为每次比较的数据类型不同，都要重新去写一个类（仿函数），如果每次比较的逻辑不一样，还要去实现多个类，特别是相同类的命名，这些都给编程者带来了极大的不便，因此，在C++11语法中出现了Lambda表达式。

2.1 lambda表达式的定义：

定义了一个可以调用的对象 / 匿名函数，一般定义在局部，特点是可以深度绑定了局部的数据。

lambda表达式书写格式：

• 普通函数有函数名，lambda函数没有函数名，他是一个整体
  
• lambda表达式，实际上是一个匿名函数，实际上是在定义一个函数（局部的函数）
• lambda表达式通常是用来定义小函数
• lambda表达式在局部是很好用的，最特别的就是捕捉列表

auto Add1 = [](int x, int y)->int{return x + y; }; Add叫lambda表达式的对象 – lambda定义的是一个对象。

lambda表达式各部分说明：

• [capture-list] : 捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[]来判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda函数使用。
• (parameters)： 参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以连同()一起省略。
• mutable： 默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性。使用该修饰符时，参数列表不可省略(即使参数为空)。
• ->returntype： 返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推导。
• {statement}： 函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的量。

注意：

• 在lambda函数定义中，参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为空。
• 因此C++11中最简单的lambda函数为：[]{}; 该lambda函数不能做任何事情。

2.2 lambda表达式的用法：

int main()
{int a = 0, b = 200;//一般是局部匿名函数  也可以写到全局（一般都不写返回值）//参数列表（无参的时候）和返回值（表达式自动推导）也可以省略掉auto Add1 = [](int x, int y)->double {return (x + y) / 3.0; };auto Add2 = [](int x, int y)->int {return (x + y) / 3.0; };//参数列表可以省略了auto Add3 = [a, b] {return (a + b) / 3.0; };//调用是和普通的函数一样的cout << Add1(a, b) << endl;cout << Add2(a, b) << endl;//调用没有区别，但是没有实参，因为捕捉了cout << Add3() << endl;
}

• 一般是局部匿名函数 也可以写到全局（一般都不写返回值）
• 参数列表（无参的时候）和返回值类型（表达式自动推导）也可以省略掉
• 和普通函数调用没区别，但是没有实参，因为捕捉了

2.2 - 1 捕捉列表的用法：

用lambda表达式来实现交换两个数：

int main()
{int a = 0, b = 200;//方法一：auto Swap1 = [](int& x, int& y)->void {int tmp = x;x = y;y = tmp;};Swap1(a, b);cout << a << " " << b << endl;//方法二：//mutable 只是让传值捕捉变量const属性去掉了//mutable要和()参数列表配在一起//可以认为里面的a，b还是外面a，b的拷贝 -- 里面改变外面还是不变//所以mutable实际没什么价值//这样写还是没有交换 -- 只是编译通过了但是达不到我们想要的效果//auto Swap2 = [a, b]()mutable->void {//	int tmp = a;//	a = b;//	b = tmp;//};//用引用的方式捕捉（按值捕捉不能改变）auto Swap2 = [&a, &b]()->void {int tmp = a;a = b;b = tmp;};Swap2();cout << a << " " << b << endl;
}

方法一：

• 就像普通函数那样传引用传参

方法二：

• 不能通过传值传参，首先捕捉列表捕捉的数据具有const属性，不能修改
• 其次mutable可以让传值捕捉变量const属性去掉了，即使去掉了
• • mutable要和()参数列表配在一起
• • 所以mutable实际没什么价值
• 可以认为里面的a，b还是外面a，b的拷贝 ，里面改变外面还是不变

所以只能按照引用的方式捕捉

各种混合捕捉：

int main()
{int c = 2, d = 3, e = 4, f = 5, g = 6, ret;//传值的方式捕捉全部对象auto Func1 = [=] {return c + d * e / f + g;};cout << Func1() << endl;//传引用捕捉全部对象auto Func2 = [&] {ret = c + d * e / f + g;};Func2();cout << ret << endl;//混着捕捉auto Func3 = [c, d, &ret] {ret = c + d;};Func3();cout << ret << endl;//ret传引用捕捉 其他全部传值捕捉auto Func4 = [=, &ret] {ret = c + d * e / f + g;//传值捕捉默认是加了const的//c = 1;};Func4();cout << ret << endl;return 0;
}

2.3 lambda表达式的类型名称：

每个lambda表达式类型的名字都是不一样的，先来看一段程序：

int main()
{auto Add = [](int x, int y)->int { return x + y; };cout << typeid(Add).name() << endl;return 0;
}

仿函数的名称后面叫uuid，一组随机字符串，通过某个算法得到的，使得每个lambda表达式的名字都不同。

lambda表达式的底层和仿函数的底层其实是一样的。

可以将lambda表达式赋值给相同类型的函数指针

不建议这样写。

3. 包装器

function包装器：
function包装器 也叫作适配器。C++中的function本质是一个类模板，也是一个包装器。

模板参数说明：

• Ret: 被调用函数的返回类型
• Args…： 被调用函数的形参

看下面一段程序：

template<class F, class T>
T useF(F f, T x)
{static int count = 0;cout << "count:" << ++count << endl;cout << "count:" << &count << endl;return f(x);
}double f(double i)
{return i / 2;
}struct Functor
{double operator()(double d){return d / 3;}
};int main()
{//函数名cout << useF(f, 11.11) << endl;//函数对象cout << useF(Functor(), 11.11) << endl;//lamber表达式cout << useF([](double d)->double{ return d / 4; }, 11.11) << endl;return 0;
}

• func可能是函数名？函数指针？函数对象(仿函数对象)？也有可能是lamber表达式对象？
• 所以这些都是可调用的类型！

如此丰富的类型，可能会导致模板的效率低下！

包装器可以很好的解决上面的问题：

• function可以认为是一个类模板，包装可调用对象
• 经过包装器包装之后得到的都是一个统一的类型function
• 最后count的地址相同，并且count到3了，说明包装器是统一了类型

注意，特殊的包装：

---

3.1 bind绑定：

简介：

std::bind函数定义在头文件中，是一个函数模板，它就像一个函数包装器(适配器)，接受一个可调用对象（callable object），生成一个新的可调用对象来“适应”原对象的参数列表。 一般而言，我们用它可以把一个原本接收N个参数的函数fn，通过绑定一些参数，返回一个接收M个（M可以大于N，但这么做没什么意义）参数的新函数。同时，使用std::bind函数还可以实现参数顺序调整等操作。

可以将bind函数看作是一个通用的函数适配器，它接受一个可调用对象，生成一个新的可调用对象来“适应”原对象的参数列表。

bind是个函数模板，调整了调用对象参数，用来调整个数和顺序，生成一个新的可调用对象：

包装器的特点就是统一了类型，但是值得注意的是包装时一定要注意匹配，如下：

这就在包装时不匹配，所在包装时一定要匹配。

下面的场景我们存一个map，这时就要求function包装器要统一了：

不过不免会有一些特殊情况：

func1和func2是可以的，但是func3就难受了呀，不匹配啊…

此时我们就可以通过bind函数来调整一下参数个数：

通过bind函数来调整顺序：



调整顺序，用处不大。