C++11进阶—在拥挤和变化的世界中茁壮成长

目录

一、前言

二、C++11进阶

1、变参模板

2、包扩展

3、emplace系列接口

4、lambda表达式

5、包装器

6、bind

7、异常

8、智能指针

三、结语

一、前言

C++11发布后，其实现相对来说很快就出现了，C++11的三个完整或几乎完整的实现在2013年面世，C++11在C++98的基础上引入了大量新的语言特性，本文将围绕C++11的进阶特性展开介绍，包括可变参数模板、lambda表达式、异常处理、智能指针等模块，C++之父Bjarne对C++11的评价是：C++11感觉像是一门新的语言，该评价在当时也得到了广泛的认可，C++11相比C++98这种在语言的"感觉"和使用风格上的巨大变化，并不是由某位大师级工匠指导的传统的精心设计过程的结果，而是海量建议经由一大批不断变化的个人层层决策过滤后的结果，使得C++11能够完成向现代C++的转型，在拥挤和变化的世界中茁壮成长。

二、C++11进阶

1、变参模板

C++11支持可变参数模板，即支持可变数量参数的函数模板和类模板，可变数目的参数称为参数包，存在两种参数包：模板参数包，表示0或多个模板参数；函数参数包，表示0或多个函数参数。

变参模板的表示方法为使用省略号来指出一个模板参数或函数参数的参数包，在模板参数列表中，class...指出接下来的参数表示0或多个类型列表，在函数参数列表中，类型名后面跟...指出接下来表示0或多个形参对象列表，函数参数包可以用左值引用或右值引用表示，与普通模板一样，每个参数实例化时也遵循引用折叠规则。

可变参数模板的原理跟模板类似，本质还是去实例化对应类型和个数的多个函数：

cpp 复制代码

#include<iostream>
#include<string>
using namespace std;
template<class...Args>
void print(Args&&...args)
{
	//...
}
int main()
{
	print();
	print(1);
	print(1, 1.1);
	print(1, string("Kzy"), string("2026-1-9"));
	return 0;
}

print可变参数模板根据参数类型和参数个数生成相应的模板，再实例化出对应的具体函数，实例化出的print函数如下所示：

cpp 复制代码

void print()
{
     //...
}
template<class K1>
void print(K1&& k1)
{
    //...
}
void print(int&& k1)
{
	//...
}
template<class K1,class K2>
void print(K1&& k1,K2&& k2)
{
    //...
}
void print(int&& k1, double&& k2)
{
	//...
}
template<class K1,class K2,class K3>
void print(K1&& k1,K2&& k2,K3&& k3)
{
    //...
}
void print(int&& k1, string&& k2, string&& k3)
{
	//...
}
int main()
{
	print();//void print()
	print(1);//void print(int&& k1)
	print(1, 1.1);//void print(int&& k1,double&& k2)
	print(1, string("Kzy"), string("2026-1-9"));//void print(int&& k1,string&& k2,string&& k3)
	return 0;
}

使用sizeof...运算符可以计算参数包中参数的个数

cpp 复制代码

#include<iostream>
#include<string>
using namespace std;
template<class...Args>
void print(Args&&...args)
{
	cout << sizeof...(args) << endl;
}
int main()
{
	print();
	print(1);
	print(1, 1.1);
	print(1, string("Kzy"), string("2026-1-9"));
	return 0;
}

print函数参数个数分别为0、1、2、3，结果如下所示：

2、包扩展

对于一个参数包，除了能计算参数包的参数个数，还可以对参数包进行扩展，扩展参数包时，需提供用于每个扩展元素的模式，扩展一个参数包就是将它分解为构成的元素，对每个元素应用模式，获得扩展后的列表，通过在模式的右边放一个省略号来触发扩展操作。

cpp 复制代码

#include<iostream>
using namespace std;
//包扩展(解析出参数包的内容）
void Showlist()//当参数包参数个数为0时，直接匹配该函数
{
	cout << endl;
}
template<class K, class...Argc>
void Showlist(K&& x, Argc&&...argc)
{
	cout << x << " ";
	Showlist(argc...);
}
template<class...Argc>
void print(Argc&&...argc)
{
	Showlist(argc...);
}
int main()
{
	print();
	print(1);
	print(1, 1.1);
	print(1, string("Kzy"), string("2026-1-9"));
	return 0;
}

可以通过包扩展解析出参数包的内容，argc是N个参数的参数包，调用Showlist模板，参数包的第一个参数传给x，剩余N-1个参数传给第二个参数包，Showlist内部再递归调用自身，编译器递归的终止条件：当参数包为0个参数时，直接匹配Showlist函数，这样就能依次解析出参数包的内容，结果如下所示：

print(1，string("Kzy")，string("2026-1-9"))，包扩展所实例化的函数如下所示：

cpp 复制代码

#include<iostream>
using namespace std;
void Showlist()
{
	cout << endl;
}
template<class K, class...Argc>
void Showlist(K&& x, Argc&&...argc)
{
	cout << x << " ";
	Showlist(argc...);
}
void Showlist(string z)
{
	cout << z << " ";
	Showlist();
}
void Showlist(string y, string z)
{
	cout << y << " ";
	Showlist(z);
}
void Showlist(int x, string y, string z)
{
	cout << x << " ";
	Showlist(y, z);
}
template<class...Argc>
void print(Argc&&...argc)
{
	Showlist(argc...);
}
int main()
{
	print(1, string("Kzy"), string("2026-1-9"));
	return 0;
}

包扩展还可以用于进行参数包的传递，Getargc用于获取参数，print将其参数通过Getargc组成参数

cpp 复制代码

#include<iostream>
#include<string>
using namespace std;
template<class K>
const K& Getargc(const K& x)
{
	cout << x << " ";
	return x;
}
template<class...Argc>
void Arguments(Argc...argc)
{

}
template<class...Argc>
void print(Argc...argc)
{
	 Arguments(Getargc(argc)...);
}
int main()
{
  print(1,string("Kzy"),1.1);
  return 0;
}

包传给Arguments，本质可以理解为编译器编译时，包的扩展模式将print函数模板扩展实例化为void print(int x，string y，double z)，如下所示：

cpp 复制代码

#include<iostream>
#include<string>
using namespace std;
template<class K>
const K& Getargc(const K& x)
{
	cout << x << " ";
	return x;
}
template<class...Argc>
void Arguments(Argc...argc)
{

}
template<class...Argc>
void print(Argc...argc)
{
	 Arguments(Getargc(argc)...);
}
void print(int x, string s, double z)
{
	Arguments(Getargc(x), Getargc(s), Getargc(z));
}
int main()
{
  print(1,string("Kzy"),1.1);//print(int x,string s,double z)
  return 0;
}

3、emplace系列接口

C++11之后STL容器新增了emplace系列的接口，emplace系列的接口均为模板可变参数，功能上兼容push和insert系列，如下所示：

cpp 复制代码

#include<iostream>
#include<string>
#include<list>
using namespace std;
int main()
{
	list<string> lt;
	string s1("111111");
	string s2("222222");
	lt.emplace_back(s1);
	lt.push_back(s1);
	lt.emplace_back(move(s1));
	lt.push_back(move(s2));
	lt.emplace_back("111111");
	lt.push_back("222222");
	return 0;
}

但emplace也有自己的新玩法，假设容器为container<K>，emplace还支持直接插入构造K对象的参数，这使得emplace在某些场景下会更高效一些，emplace可以直接在容器空间上构造K对象，emplace_back总体而言相比insert和push系列更高效。

鉴于emplace系列接口直接通过参数进行构造的原理，这里模拟实现出list的emplace与emplace_back接口，可通过参数包来模拟实现，如下所示：

cpp 复制代码

#pragma once
#include<assert.h>
namespace YZK
{
	template<class K>
	struct list_node
	{
		K _data;
		list_node<K>* _next;
		list_node<K>* _prev;
		template<class...Argc>
		list_node(Argc&&...argc)
			:_data(std::forward<Argc>(argc)...)
			, _prev(nullptr)
			, _next(nullptr)
		{
		}
	};
	template<class K, class Ref, class Ptr>
	struct list_iterator
	{
		typedef list_node<K> Node;
		typedef list_iterator<K, Ref, Ptr> Self;
		Node* _PNode;
		list_iterator(Node* PNode)
			:_PNode(PNode)
		{
		}
		Ref operator*()
		{
			return _PNode->_data;
		}
		Ptr operator->()
		{
			return &_PNode->_data;
		}
		Self& operator++()
		{
			_PNode = _PNode->_next;
			return *this;
		}
		Self& operator--()
		{
			_PNode = _PNode->_prev;
			return *this;
		}
		Self operator++(int)
		{
			Self tmp(*this);
			_PNode = _PNode->_next;
			return tmp;
		}
		Self operator--(int)
		{
			Self tmp(*this);
			_PNode = _PNode->_prev;
			return tmp;
		}
		bool operator!=(const Self& s) const
		{
			return _PNode != s._PNode;
		}
		bool operator==(const Self& s) const
		{
			return _PNode == s._PNode;
		}
	};	
	template<class K>
	class list
	{
		typedef list_node<K> Node;
	public:
		typedef list_iterator<K, K&, K*> iterator;
		typedef list_iterator<K, const K&, const K*> const_iterator;
		iterator begin()
		{
			return _head->_next;
		}
		iterator end()
		{
			return _head;
		}
		const_iterator begin() const
		{
			return _head->_next;
		}
		const_iterator end() const
		{
			return _head;
		}
		void empty_init()
		{
			_head = new Node;
			_head->_next = _head;
			_head->_prev = _head;
			_size = 0;
		}
		list()
		{
			empty_init();
		}
		list(initializer_list<K> il)
		{
			empty_init();
			for (auto& e : il)
			{
				push_back(e);
			}
		}
		list(const list<K>& lt)
		{
			empty_init();
			for (auto& e : lt)
			{
				push_back(e);
			}
		}
		list<K>& operator=(list<K> lt)
		{
			swap(lt);
			return *this;
		}
		~list()
		{
			clear();
			delete _head;
			_head = nullptr;
		}
		void clear()
		{
			auto it = begin();
			while (it != end())
			{
				it = erase(it);
			}
		}
		void swap(list<K>& lt)
		{
			std::swap(_head, lt._head);
			std::swap(_size, lt._size);
		}
		void push_back(const K& x)
		{
			insert(end(), x);
		}
		void push_back(K&& x)
		{
			insert(end(), forward<K>(x));
		}
		template<class...Argc>
		void emplace_back(Argc&&...argc)
		{
			insert(end(), std::forward<Argc>(argc)...);
		}
		void push_front(const K& x)
		{
			insert(begin(), x);
		}
		template<class...Argc>
		iterator insert(iterator pos, Argc&&...argc)
		{
			Node* cur = pos._PNode;
			Node* prev = cur->_prev;
			Node* newnode = new Node(std::forward<Argc>(argc)...);
			newnode->_next = cur;
			cur->_prev = newnode;
			newnode->_prev = prev;
			prev->_next = newnode;
			++_size;
			return iterator(newnode);
		}
		void pop_back()
		{
			erase(--end());
		}
		void pop_front()
		{
			erase(begin());
		}
		iterator erase(iterator pos)
		{
			assert(pos != end());
			Node* prev = pos._PNode->_prev;
			Node* next = pos._PNode->_next;
			prev->_next = next;
			next->_prev = prev;
			delete pos._PNode;
			--_size;
			return next;
		}
		size_t size() const
		{
			return _size;
		}
		bool empty() const
		{
			return _size == 0;
		}
	private:
		Node* _head;
		size_t _size;
	};
}

通过将参数包不断向下传递，最终在结点的构造中直接匹配容器存储的数据类型K的构造，从而达到了emplace支持直接插入构造K对象的参数，这使得emplace在某些场景下会更高效一些，可以直接在容器空间上构造对象，需要注意的是，在传递参数包的过程中，如果是Argc&&...argc的参数包，需要使用完美转发参数包，即std::forward<Argc>(argc)...，避免编译时包扩展后右值引用变量表达式变成了左值。

cpp 复制代码

#include<iostream>
#include<string>
#include"list.h"
using namespace std;
int main()
{
	YZK::list<pair<string, int>> lt;
	pair<string, int> kv("Kzy",1 );
	lt.emplace_back(kv);
	lt.emplace_back(move(kv));
	lt.emplace_back("hello",1 );//直接通过参数进行构造
    lt.push_back({ "hello",1 });
	return 0;
}

emplace系列兼容push和insert的功能，相比push、insert最大的区别在于emplace系列可直接通过参数进行构造，push和insert则无法直接通过参数进行构造，因此在某些场景下emplace系列接口更高效一些。

4、lambda表达式

lambda表达式本质是一个匿名函数对象，与普通函数不同的是lambda表达式可以定义在函数内部，lambda表达式语法对于使用层而言没有类型，一般用auto或模板参数定义的对象去接收lambda对象。

lambda表达式的格式为：[捕捉列表] (参数列表)->返回值类型 {函数体}