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

文章目录

• 1. 可变参数模板
• • 1.1 介绍
  • 1.2 emplace系列接口实现
• 2. lambda表达式
• • 2.1 语法介绍
  • 2.2 原理
• 3. 包装器
• 4. bind

1. 可变参数模板

1.1 介绍

可变参数我们在C语言阶段已经了解过了，C语言中叫做可变参数列表，其中使用 ... 代表可变参数。
C语言中的可变参数列表链接

由于C++中增加了模板，因此C++11中就引进了可变参数模板，其能够创建可以接受可变参数的函数模板和类模板，相比C++98/03，类模版和函数模版中只能含固定数量的模版参数，可变模版参数无疑是一个巨大的改进。

C++中的可变参数模板延续了C语言中可变参数列表中 ... 的使用。

下面就是一个基础的可变参数的函数模板

上面的参数args前面有省略号，所以它就是一个可变模版参数，我们把带省略号的参数称为“参数包”，它里面包含了0到N（N>=0）个模版参数。

注意使用方式：

• template<class ...Args> ，作为模板参数包时，...在前，
• Args... args，作为函数形参参数包时，...在后
• 函数参数args进行传递时，应这样传递，args...，…在args的后面

我们可以使用sizeof...(args)检查参数的个数

那我们能不能显示参数包中的数据呢？

注意：解析模板参数包是在编译时做的，上述代码是在运行时，所以是不可能显示出来的。

我们无法直接获取参数包args中的每个参数的，只能通过展开参数包的方式来获取参数包中的每个参数，这是使用可变模版参数的一个主要特点，也是最大的难点，即如何展开可变模版参数。
由于语法不支持使用args[i]这样方式获取可变参数，所以我们的用一些其它方式获取参数包的值。

• 递归函数方式展开参数包

这样就可以一一进行打印了。

• 逗号表达式展开参数包

这种展开参数包的方式，不需要通过递归终止函数，是直接就地展开的, PrintArg不是一个递归终止函数，只是一个处理参数包中每一个参数的函数。

这种就地展开参数包的方式实现的关键是逗号表达式。

• 逗号表达式：(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数组的过程中就将参数包展开了，这个数组的目的纯粹是为了在数组构造的过程展开参数包。

1.2 emplace系列接口实现

学习完可变参数模板后，我们就可以试着来实现以下STL中容器的emplace系列接口。

这里我们就以list为例，我们看到它不仅使用了可变参数模板，而且使用了万能引用。

注意：尽管emplace_back是可变参数模板，但是它不支持插入多个值

那它支持可变模板参数是干什么的呢？

对于多参数的，例如一个pair类型，无论是使用push_back还是emplace_back插入一个pair对象，二者没有区别，都是构造pair+拷贝/移动构造。

但是对于没有pair对象的第三种情况而言，它把构造pair的参数作为可变参数包直接往下传，不断地传；直到传到链表节点那个地方使用pair的参数直接去构造节点，没有了“中间商”，因此只有一个构造。

因此我们emplace_back可以按照下面的方式写，对于未使用对象操作，仅使用构造对象的参数进行传参的，都直接构造。

参数传递时注意右值的退化，合理使用完美转发！

emplace_back高效原因总结：

• 原地构造：emplace_back 允许在容器内部直接构造元素，而不需要先创建一个临时对象，然后再将其复制或移动到容器中。这避免了额外的复制或移动操作，从而提高了效率。
• 优化构造函数调用：使用 emplace_back 时，可以直接传递构造函数的参数给容器，而不是先构造一个完整的对象。这允许编译器优化构造函数的调用，例如通过完美转发来减少不必要的拷贝和移动操作。
• 避免拷贝/移动构造函数和析构函数的调用：对于需要在容器中添加大量复杂对象时，emplace_back 通过直接构造对象，避免了临时对象的拷贝或移动构造函数的调用，同时也避免了在容器销毁时这些临时对象的析构函数调用。这可以显著提高性能，尤其是在对象构造、析构或拷贝/移动操作开销较大时。
• 与 std::move 相比的优势：虽然 std::move 可以与 push_back 结合使用以减少拷贝开销，但它仍然需要构造一个临时对象（尽管是一个右值引用），然后再将其移动到容器中。相比之下，emplace_back 直接在容器内部构造对象，完全避免了临时对象的创建。

综上所述，emplace_back 通过在容器内部直接构造元素，减少了拷贝/移动操作，优化了内存使用，并避免了不必要的构造函数和析构函数调用，从而提供了比 push_back 更高效的元素添加方式。在可能的情况下，优先使用 emplace_back 可以显著提升性能。

2. lambda表达式

在C++98中，如果想要对一个数据集合中的元素进行排序，可以使用std::sort方法。

int main() { 	int array[] = { 4,1,8,5,3,7,0,9,2,6 }; 	// 默认按照小于比较，排出来结果是升序 	size_t sz = sizeof(array) / sizeof(array[0]); 	sort(array, array + sz );  	// 如果需要降序，需要改变元素的比较规则 	sort(array, array + sz, greater<int>()); 	return 0; } 

对于自定义类型的数据，需要自己定义比较规则。

随着C++语法的发展，人们开始觉得上面的写法太复杂了，每次为了实现一个algorithm算法，都要去写一个类并在类中实现仿函数，如果每次比较的逻辑不一样，还要去实现多个类和仿函数，特别是相同类的命名，这些都给编程者带来了极大的不便。因此，在C++11语法中出现了Lambda表达式。

2.1 语法介绍

lambda表达式书写格式：[捕捉列表] (参数列表) mutable -> 返回值类型 { 函数体 }。它的结构类似于函数，唯独没有函数名。

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

1. 简单的lambda表达式

对于捕捉列表和mutable我们稍后在描述，先简单写一个lambda看一看。

尽管返回值类型可以省略，但是还是推荐写上。

现在我们就可以使用lambda改造上面排序的比较规则

这样直接在当前位置写是不是就清爽很多，不必再像以前一样先写个类，然后重载operator()了

通过上述例子可以看出，lambda表达式实际上可以理解为无名函数，该函数无法直接调用，如果想要直接调用，可借助auto将其赋值给一个变量

2. 捕捉列表

mutable可以取消其常量性

• 传值捕捉，我们发现其实a，b在外部并未被交换

所以我们必须要了解捕获列表说明：

捕捉列表描述了上下文中哪些数据可以被lambda使用，以及使用的方式传值还是传引用。

• [var]：表示值传递方式捕捉变量var
• [=]：表示值传递方式捕获所有父作用域中的变量(包括this)
  • 父作用域指包含lambda函数的语句块
• [&var]：表示引用传递捕捉变量var
• [&]：表示引用传递捕捉所有父作用域中的变量(包括this)
• [this]：表示值传递方式捕捉当前的this指针

• 传引用捕捉

• 所有值都传值捕捉

• 所有值都传引用捕捉

• 混合使用（捕捉列表可由多个捕捉项组成，并以逗号分割）

注意：

• 捕捉列表不允许变量重复传递，否则就会导致编译错误
  
• 在块作用域中的lambda函数仅能捕捉父作用域中局部变量或全局变量，捕捉任何非此作用域或者非局部变量都会导致编译报错
• lambda表达式之间不能相互赋值，即使看起来类型相同
  

2.2 原理

我们先使用重载operator()和lambda写同一个功能，观察底层实现

class Rate { public: 	Rate(const double& rate) 		:_rate(rate) 	{} 	double operator()(double money, int year) 	{ 		return   money * _rate * year; 	} private: 	double _rate; };  int main() { 	//使用类对象重载的operator() 	double rate = 0.015; 	Rate r1(rate); 	cout << r1(10000, 2) << endl;  	//使用lambda 	auto func = [=](double money, int year)->double  	{ 		return money * rate * year;  	}; 	cout << func(10000, 2) << endl; 	return 0; } 

从使用方式上来看，函数对象与lambda表达式完全一样。

函数对象将rate作为其成员变量，在定义对象时给出初始值即可，lambda表达式通过捕获列表可以直接将该变量捕获到，然后通过传参传进去。

我们查看汇编代码可以发现，实际在底层编译器对于lambda表达式的处理方式，完全就是按照函数对象的方式处理的，即：如果定义了一个lambda表达式，编译器会自动生成一个类，在该类中重载了operator()。

3. 包装器

• function包装器

function包装器 也叫作适配器。C++中的function本质是一个类模板，也是一个包装器。
那么我们来看看，我们为什么需要function呢？

到目前位置，我们知道的可调用对象有：函数指针、仿函数、lambda表达式三种，下面我们就用这三种来实现三个不同的函数。

template<class F, class T> T Transfer(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 << Transfer(f, 66.6) << endl << endl; 	// 函数对象（仿函数） 	cout << Transfer(Functor(), 66.6) << endl << endl; 	// lamber表达式 	cout << Transfer([](double d)->double { return d / 4; }, 66.6) << endl << endl; 	return 0; } 

我们都知道，静态变量在一个语句块中是同一个，但是下面的代码中却不是。显然它们调用的不是同一个Transfer，由于这里模板的原因，编译器在底层会根据不同的函数模板实例化出不同的Transfer函数，导致效率低下。

同时，如果我们要把可调用对象存储到一个容器中，那容器元素的类型是什么呢？函数指针、仿函数还是lambda表达式？很显然都不行。

为了解决这个问题，C++11引入了std::function包装器，它可以将这些不同类型的可调用对象（参数、返回值相同）封装成统一的类型，使得函数模板和容器等可以更加灵活地处理这些对象。

包装器的语法比较怪，使用它需要包含对应的头文件functional；其次它是一个类，类的模板参数和平常的不一样。

还可以使用包装器包装类的成员函数：

使用包装器包装后，就无需再实例化多个Transfer函数，此时不同类型的可调用参数对象都是同一种类型了。

包装器的应用

题目链接：逆波兰表达式

右边的代码使用包装器使代码更加的灵活

4. bind

bind函数定义在头文件functional中，是一个函数模板，它就像一个函数包装器(适配器)，接受一个可调用对象，生成一个新的可调用对象来“适应”原对象的参数列表。

一般而言，我们用它可以把一个原本接收N个参数的函数fn，通过绑定一些参数，返回一个接收M个（M一般小于N）参数的新函数。同时，使用std::bind函数还可以实现参数顺序调整等操作。

一句话总结：bind可以调整一个可调用对象的参数的个数和顺序。

原型如下：

该函数的参数

• Fn：可调用对象
• 可变参数模板Args：要么是值，要么是placeholder(一个命名空间)

• 调整参数的顺序（不常用）

• 调整参数个数（常用）

绑定某些参数，其余参数通过调用时传递

对于调整参数的个数而言，更加适合下面这种场景，可以简化调用