【C++】C++11新特性：列表初始化、声明、新容器、右值引用、万能引用和完美转发

目录

一、列表初始化

[1.1 { } 初始化](#1.1 { } 初始化)

[1.2 std::initializer_list](#1.2 std::initializer_list)

二、声明

[2.1 auto](#2.1 auto)

[2.2 decltype](#2.2 decltype)

[2.3 nullptr](#2.3 nullptr)

三、新容器

四、右值引用和移动语义

[4.1 左值和左值引用](#4.1 左值和左值引用)

[4.2 右值和右值引用](#4.2 右值和右值引用)

[4.3 左值引用与右值引用比较](#4.3 左值引用与右值引用比较)

[4.4 右值引用使用场景和意义：移动构造、移动赋值](#4.4 右值引用使用场景和意义：移动构造、移动赋值)

4.5右值引用引用左值及其一些更深入的使用场景分析

五、万能引用和完美转发

[5.1 万能引用](#5.1 万能引用)

[5.2 完美转发](#5.2 完美转发)

---

一、列表初始化

1.1 { } 初始化

在C++98中，标准允许使用花括号{}对数组或者结构体元素进行统一的列表初始值设定。比如：

struct Point
{
	int _x;
	int _y;
};

int main()
{
	int array1[] = { 1, 2, 3, 4, 5 };
	int array2[5] = { 0 };
	Point p = { 1, 2 };

	return 0;
}

C++11扩大了用大括号括起的列表(初始化列表)的使用范围，使其可用于所有的内置类型和用户自

定义的类型，使用初始化列表时可以省略赋值符号，即可以添加等号(=)，也可以不添加。

class Date
{
public:
	Date(int year, int month, int day)
		:_year(year)
		, _month(month)
		, _day(day)
	{
		cout << "Date(int year, int month, int day)" << endl;
	}

private:
	int _year;
	int _month;
	int _day;
};

 //一切都可以用列表初始化
 //并且可以省略掉=
int main()
{
	int i = 0;
	int j = { 0 };
	int k{ 0 };

	int array1[]{ 1, 2, 3, 4, 5 };
	int array2[5]{ 0 };
	Point p{ 1, 2 };

    //创建对象时也可以使用列表初始化方式调用构造函数初始化
	Date d1(1949, 10, 1);//构造函数

	// 类型转换:  构造+拷贝构造->编译器优化为直接构造
	Date d2 = { 1949, 10, 2 };
	Date d3{ 1949, 10, 3 };

	//单参数的构造函数支持隐式类型转换
	string s1 = "xxxx";

	const Date& d4 = { 1949, 10, 1 };

	Date* p1 = new Date[3]{ d1, d2, d3 };
	Date* p2 = new Date[3]{ {1949, 10, 1}, {1949, 10, 2}, {1949, 10, 3} };

	return 0;
}

1.2 std::initializer_list

在 C++11 中，initializer_list 是一个新的模板类型，它是 std::initializer_list<T> 的缩写，用于表示一组值的集合。std::initializer_list的介绍文档

查看std::initializer_list是什么类型：

int main()

{

// the type of il is an initializer_list

auto il = { 10, 20, 30 };

cout << typeid(il).name() << endl;

return 0;

}

使用场景： std::initializer_list一般是作为构造函数的参数，C++11对STL中的不少容器就增加std::initializer_list作为参数的构造函数，例如vector、list和map，这样初始化容器对象就更方便了。也可以作为operator=的参数，这样就可以用大括号赋值。

在下面的示例中。

• Date d2 = { 1949, 10, 1 };的列表不转换成initializer_list，而是通过构造函数构造临时对象，再通过拷贝构造赋给d2。
• initializer_list支持迭代器和范围for。
• 在map<string, string> dict = {{"insert", "插入"}, {"get","获取"} };使用 initializer_list 直接在初始化表达式中指定键值对，不需要显式地创建一个临时对象

int main()
{
	//默认识别成initializer_list
	vector<int> v1 = { 1,2,3,4 };
	vector<int> v2 = { 1,2,3,4,5,6};

	v1 = { 10,20,30 };

	list<int> lt = { 10,20,30 };

	// 多参数构造类型转换  构造+拷贝构造->优化直接构造
	// 跟对应构造函数参数个数匹配
	Date d2 = { 1949, 10, 2 };

	initializer_list<int> il2 = { 10, 20, 30};

	initializer_list<int>::iterator it2 = il2.begin();
	while (it2 != il2.end())
	{
		cout << *it2 << " ";
		++it2;
	}
	cout << endl;
	
	//for (int e : il2)
	for (auto e : il2)
	{
		cout << e << " ";
	}
	cout<< endl;

	pair<string, string> kv1("sort", "排序");
	map<string, string> dict = {{"insert", "插入"}, {"get","获取"} };
	for (auto& kv : dict)
	{
		cout << kv.first << ":" << kv.second << endl;
	}

	Date dd2 = { 1949, 10, 1 };
	//Date dd3 = { 1949, 10, 1, 20};

	return 0;
}

二、声明

2.1 auto

在C++98中auto是一个存储类型的说明符，表明变量是局部自动存储类型，但是局部域中定义局

部的变量默认就是自动存储类型，所以auto就没什么价值了。C++11中废弃auto原来的用法，将
其用于实现自动类型推断，它允许编译器自动推导变量的类型。使用auto必须进行显示初始化，让编译器将定义对象的类型设置为初始化值的类型。

2.2 decltype

在 C++11 中，decltype 是一个关键字，用于返回表达式的类型。decltype 通常与 auto 一起使用，以提供更加灵活和强大的类型推断能力。

decltype推导出来的类型可以用来当作模板实参，或者定义对象。（typeid获取的类型不能用来定义对象）

int main()
{
	int i = 1;
	double d = 2.2;

	// 类型以字符串形式获取到
	cout << typeid(i).name() << endl;
	cout << typeid(d).name() << endl;

	// typeid(i).name() j; //typeid获取的类型不能用来定义对象
	auto j = i;

	auto ret = i * d;
	decltype(ret) x;

	// 用ret的类型去实例化vector
	// decltype可以推导对象的类型。这个类型是可以用
	// 用来模板实参，或者再定义对象
	vector<decltype(ret)> v;
	v.push_back(1);
	v.push_back(1.1);
	for (auto e : v)
	{
		cout << e << " ";
	}
	cout << endl;

	return 0;
}

2.3 nullptr

由于C++中NULL被定义成字面量0，这样就可能回带来一些问题，因为0既能指针常量，又能表示

整形常量。所以出于清晰和安全的角度考虑，C++11中新增了nullptr，用于表示空指针。

#ifndef NULL
#ifdef __cplusplus
#define NULL   0
#else
#define NULL   ((void *)0)
#endif
#endif

三、新容器

用橘色圈起来是C++11中的一些几个新容器，但是实际最有用的是unordered_map和

unordered_set。这两个我前面已经进行了非常详细的讲解，其他的大家了解一下即可。

C语言没有办法进行很好的越界检查(C语言是抽查)，[ ]就可以检查出来读/写是否越界。

array很少用，因为已经有了vector。forward_list只有头插头删。

如果我们再细细去看会发现基本每个容器中都增加了一些C++11的方法，但是其实很多都是用得

比较少的。

比如提供了cbegin和cend方法返回const迭代器等等，但是实际意义不大，因为begin和end也是

可以返回const迭代器的，这些都是属于锦上添花的操作

四、右值引用和移动语义

4.1 左值和左值引用

传统的C++语法中就有引用的语法，而C++11中新增了的右值引用语法特性，所以从现在开始我们
之前学习的引用就叫做左值引用。无论左值引用还是右值引用，都是给对象取别名。

什么是左值？什么是左值引用？

• 左值是一个表示数据的表达式(如变量名或解引用的指针)，我们可以获取它的地址并且可以对它赋值。
• 左值可以出现赋值符号的左边，也可以出现在右边，右值不能出现在赋值符号左边。
• 定义时const修饰符后的左值，不能给他赋值，但是可以取它的地址。
• 左值引用就是给左值的引用，给左值取别名。
• 区分左值和右值要看能不能取它的地址，能取地址的是左值，不能取地址的是右值。

int main()
{
	// 以下的p、b、c、*p都是左值
	int* p = new int(0);
	int b = 1;
	const int c = 2;
	// 以下几个是对上面左值的左值引用
	int*& rp = p;
	int& rb = b;
	const int& rc = c;
	int& pvalue = *p;
	return 0;
}

4.2 右值和右值引用

什么是右值？什么是右值引用？

1. 右值也是一个表示数据的表达式，如：字面常量、表达式返回值，函数返回值(这个不能是左值引用返回)等等。
2. 右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边。
3. 右值不能取地址。
4. 右值引用就是对右值的引用，给右值取别名。

int main()
{
	double x = 1.1, y = 2.2;
	// 以下几个都是常见的右值
	10;
	x + y;
	fmin(x, y);
	// 以下几个都是对右值的右值引用
	int&& rr1 = 10;
	double&& rr2 = x + y;
	double&& rr3 = fmin(x, y);
	// 这里编译会报错：error C2106: "=": 左操作数必须为左值
	10 = 1;
	x + y = 1;
	fmin(x, y) = 1;
	return 0;
}

4.3 左值引用与右值引用比较

右值引用总结：

1. 左值引用只能引用左值，不能引用右值。
2. 但是const左值引用既可引用左值，也可引用右值。

右值引用总结：

1. 左值引用不能给右值取别名，但是const左值引用可以。
2. 右值引用不能给左值取别名，但是右值引用可以给move(左值)取别名

int main()
{
	int i = 0;
	int j = i;
	
	// 左值引用能否给右值取别名？不能，但是const左值引用可以
	//int& r1 = 10;//出错
	const int& r2 = i + j;

	int&& rr1 = 10;
	int&& rr2 = i+j;

	// 右值引用能否给左值取别名？不能，但是右值引用可以给move(左值)取别名
	//int&& rr3 = i;//出错
	int&& rr4 = move(i);

	return 0;
}

4.4 右值引用使用场景和意义：移动构造、移动赋值

右值引用的主要目的是为了优化性能，特别是在实现移动语义时，可以避免不必要的拷贝操作，提高性能。

移动语义：

在 C++ 中，当一个对象被另一个对象所需要时，通常会发生拷贝操作。例如，当函数需要一个对象作为参数时，通常会创建该对象的一个副本。
使用右值引用，可以避免这种不必要的拷贝操作，而是直接移动（move）对象。这被称为移动语义，它通常比拷贝操作更快，因为它不涉及创建副本，而是直接移动对象的数据。

注：右值引用的移动语义对于深拷贝的类有意义，对于自定义类型浅持贝的类无意义，例如Date

例如swap函数在C++11中进行改变：

自定义类型使用右值引用的场景：

namespace mystring
{
	class string
	{
	public:
		typedef char* iterator;
		iterator begin()
		{
			return _str;
		}

		iterator end()
		{
			return _str + _size;
		}

		string(const char* str = "")
			:_size(strlen(str))
			, _capacity(_size)
		{
			cout << "string(char* str) -- 构造" << endl;

			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}

		// s1.swap(s2)
		void swap(string& s)
		{
			std::swap(_str, s._str);
			std::swap(_size, s._size);
			std::swap(_capacity, s._capacity);
		}

		// 拷贝构造
		string(const string& s)
		{
			cout << "string(const string& s) -- 深拷贝" << endl;


			_str = new char[s._capacity + 1];
			strcpy(_str, s._str);
			_size = strlen(_str);
			_capacity = s._capacity + 1;
		}

		// 赋值重载
		string& operator=(const string& s)
		{
			cout << "string& operator=(const string& s) -- 深拷贝" << endl;
			/*string tmp(s);
			swap(tmp);*/
			if (this != &s)
			{
				char* tmp = new char[s._capacity + 1];
				strcpy(tmp, s._str);

				delete[] _str;
				_str = tmp;
				_size = s._size;
				_capacity = s._capacity;
			}

			return *this;
		}

		~string()
		{
			delete[] _str;
			_str = nullptr;
		}

		char& operator[](size_t pos)
		{
			assert(pos < _size);
			return _str[pos];
		}

		void reserve(size_t n)
		{
			if (n > _capacity)
			{
				char* tmp = new char[n + 1];
				strcpy(tmp, _str);
				delete[] _str;
				_str = tmp;

				_capacity = n;
			}
		}

		void push_back(char ch)
		{
			if (_size >= _capacity)
			{
				size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
				reserve(newcapacity);
			}

			_str[_size] = ch;
			++_size;
			_str[_size] = '\0';
		}

		//string operator+=(char ch)
		string& operator+=(char ch)
		{
			push_back(ch);
			return *this;
		}

		const char* c_str() const
		{
			return _str;
		}
	private:
		char* _str = nullptr;
		size_t _size = 0;
		size_t _capacity = 0; // 不包含最后做标识的\0
	};

	mystring::string to_string(int x)
	{
		mystring::string ret;
		while (x)
		{
			int val = x % 10;
			x /= 10;
			ret += ('0' + val);
		}

		reverse(ret.begin(), ret.end());

		return ret;
	}
}

int main()
{
	mystring::string s ;
	s = mystring::to_string(1234);

	return 0;
}

Debug版本下：

release版本下：（连续的构造加拷贝构造优化为一次直接构造）

发生许多次构造的原因：

mystring::string to_string(int x)
{
mystring::string ret;
while (x)
{
int val = x % 10;
x /= 10;
ret += ('0' + val);
}

reverse(ret.begin(), ret.end());

return ret;
}

to_string会创建、构造一个ret，ret在栈上有自己空间，在返回时传给返回值临时对象，使用拷贝构造，并且该临时对象也在栈上有自己的空间，返回时使用赋值重载，并将ret和临时对象使用的空间释放。这种拷贝操作就是不必要的拷贝操作。即使release版本优化后也会浪费时间和空间。

这时就要使用移动构造和移动赋值。

		// 移动构造
		string(string&& s)
		{
			cout << "string(string&& s) -- 移动拷贝" << endl;

			swap(s);
		}

		// 移动赋值
		string& operator=(string&& s)
		{
			cout << "string& operator=(string&& s)-- 移动赋值" << endl;

			swap(s);
			return *this;
		}

Debug版本：

release版本：

可以看到return ret 给临时对象不再是深拷贝，而是直接交换，临时对象给s赋值时也是移动赋值，直接交换数据，这时ret和临时对象出作用域销毁时直接把s原本的不用的数据顺便销毁了。

4.5右值引用引用左值及其一些更深入的使用场景分析

按照语法，右值引用只能引用右值，但右值引用一定不能引用左值吗？

因为有些场景下，可能真的需要用右值去引用左值实现移动语义。当需要用右值引用引用一个左值时，可以通过move函数将左值转化为右值。 C++11中，std::move()函数 位于头文件中，该函数名字具有迷惑性，它并不搬移任何东西，唯一的功能就是将一个左值强制转化为右值引用，然后实现移动语义。

//move的定义
//template<class _Ty>
//inline typename remove_reference<_Ty>::type&& move(_Ty&& _Arg) _NOEXCEPT
//{
//	// forward _Arg as movable
//	return ((typename remove_reference<_Ty>::type&&)_Arg);
//}

int main()
{
	mystring::string s1("hello world");
	// 这里s1是左值，调用的是拷贝构造
	mystring::string s2(s1);
	// 这里我们把s1 move处理以后, 会被当成右值，调用移动构造
	// 但是这里要注意，一般是不要这样用的，因为我们会发现s1的
	// 资源被转移给了s3，s1被置空了。
	mystring::string s3(std::move(s1));
	return 0;
}

STL容器插入接口函数也增加了右值引用版本：

五、万能引用和完美转发

5.1 万能引用

在 C++11 之前，模板参数默认情况下是左值引用。这意味着模板函数或模板模板参数默认只能接收左值引用类型的参数。为了接收右值引用类型的参数，需要显式地指定模板参数为右值引用。

C++11 引入了万能引用的概念，使得模板参数可以同时接受左值引用和右值引用类型的参数。 万能引用通常是通过模板参数上的 && 类型参数来实现的，例如：

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; }

// 函数模板：万能引用
template<typename T>
void PerfectForward(T&& t)
{
	Fun(t);
}

特点：

• 模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值。
• 模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力，
• 但是引用类型的唯一副作用就是限制了接收的类型，参数在后续使用中都退化成了左值，
• 我们希望能够在传递过程中保持它的左值或者右值的属性, 就需要用我们下面学习的完美转发

右值不能直接修改，但是右值被右值引用后，需要被修改，否则无法实现移动构造和移动赋值(也就无法转移资源)。这就需要右值引用的属性是左值才能修改。

为什么万能引用的参数在后续使用中都退化成了左值，如何确定实参的属性？

具体来说，当一个函数模板接受一个右值引用类型的参数时，这个参数在函数内部被视为右值。但是，一旦该参数被传递给函数，它的引用特性就会退化，因为它在函数内部被绑定到一个具体的对象上，而这个对象在函数内部是可修改的。这种绑定会改变参数的语义，使其在后续的使用中被视为左值。

这样可以确保函数内部对参数的修改不会影响到外部环境中的原始对象。但是，这也意味着函数内部不能直接使用右值引用的语义来执行某些操作，例如移动语义。

为了解决这个问题，C++11 引入了 std::forward 模板，它可以用来转发参数，保持参数的引用特性不变。这种方法也叫做完美转发。

上面说到STL容器插入接口函数也增加了右值引用版本，其实也是增加了万能引用版本，在内部实现时可以使用完美转发确定实参的属性(左值/右值)，进而进行相应的操作。

例如右值被万能引用后，这个引用是左值，必要时需要move()转换为右值。

5.2 完美转发

完美转发是指在函数模板或类模板中转发参数时，保持参数类型的引用特性不变。这意味着如果原始参数是左值引用，转发后的参数也是左值引用；如果原始参数是右值引用，转发后的参数也是右值引用。

C++11 提供了两种方法来实现完美转发：

1. 通过万能引用：

template<typename T>

void PerfectForward(T&& t)

{

// 这里 t 保持原始参数的引用特性

Fun(std::forward<T>(t) );// 使用 std::forward 进行转发

}

注：如果 T 被推断为右值引用类型（例如 T 被推断为 int&&），那么 std::forward<T>(t) 将返回一个右值引用，这意味着它返回的是一个临时的右值，而不是 t 本身变成右值。
2. 针对Fun传入的参数调用特定的函数模板：

template <typename T>

void Func(const T& t)

{}

template <typename T>

void Func(T&& t)

{}

完美转发中实际的使用场景：

	template<class T>
	struct list_node
	{
		T _data;
		list_node<T>* _next;
		list_node<T>* _prev;

		list_node(const T& x = T())
			:_data(x)
			,_next(nullptr)
			,_prev(nullptr)
		{}

		list_node(T&& x)
			:_data(move(x))
			, _next(nullptr)
			, _prev(nullptr)
		{}

		template <class... Args>
		list_node(Args&&... args)
			:_data(args...)
			,_next(nullptr)
			,_prev(nullptr)
		{}
	};

	// T T& T*
	// T cosnt T& const T*
	template<class T, class Ref, class Ptr>
	struct __list_iterator
	{
		typedef list_node<T> Node;
		typedef __list_iterator<T, Ref, Ptr> self;
		Node* _node;

		__list_iterator(Node* node)
			:_node(node)
		{}

		self& operator++()
		{
			_node = _node->_next;
			return *this;
		}

		self& operator--()
		{
			_node = _node->_prev;
			return *this;
		}

		self operator++(int)
		{
			self tmp(*this);
			_node = _node->_next;

			return tmp;
		}

		self operator--(int)
		{
			self tmp(*this);
			_node = _node->_prev;

			return tmp;
		}

		Ref operator*()
		{
			return _node->_data;
		}

		Ptr operator->()
		{
			return &_node->_data;
		}

		bool operator!=(const self& s)
		{
			return _node != s._node;
		}

		bool operator==(const self& s)
		{
			return _node == s._node;
		}
	};

	template<class T>
	class list
	{
		typedef list_node<T> Node;
	public:
		typedef __list_iterator<T, T&, T*> iterator;
		typedef __list_iterator<T, const T&, const T*> const_iterator;

		//typedef __list_const_iterator<T> const_iterator;

		const_iterator begin() const
		{
			return const_iterator(_head->_next);
		}

		const_iterator end() const
		{
			return const_iterator(_head);
		}

		iterator begin()
		{
			//return iterator(_head->_next);
			return _head->_next;
		}

		iterator end()
		{
			//return iterator(_head->_next);
			return _head;
		}

		void empty_init()
		{
			_head = new Node;
			_head->_next = _head;
			_head->_prev = _head;

			_size = 0;
		}

		list()
		{
			empty_init();
		}

		// lt2(lt1)
		list(const list<T>& lt)
		{
			empty_init();
			for (auto e : lt)
			{
				push_back(e);
			}
		}

		void swap(list<T>& lt)
		{
			std::swap(_head, lt._head);
			std::swap(_size, lt._size);
		}

		// lt3 = lt1
		list<int>& operator=(list<int> lt)
		{
			swap(lt);

			return *this;
		}

		~list()
		{
			clear();

			delete _head;
			_head = nullptr;
		}

		void clear()
		{
			iterator it = begin();
			while (it != end())
			{
				it = erase(it);
			}
		}

		void push_back(const T& x)
		{
			insert(end(), x);
		}

		void push_back(T&& x)
		{
			insert(end(), forward<T>(x));
		}

		template <class... Args>
		void emplace_back(Args&&... args)
		{
			Node* newnode = new Node(args...);
			// 链接节点
		}

		void push_front(const T& x)
		{
			insert(begin(), x);
		}

		void pop_front()
		{
			erase(begin());
		}

		void pop_back()
		{
			erase(--end());
		}

		iterator insert(iterator pos, const T& x)
		{
			Node* cur = pos._node;
			Node* newnode = new Node(x);

			Node* prev = cur->_prev;

			// prev newnode cur
			prev->_next = newnode;
			newnode->_prev = prev;

			newnode->_next = cur;
			cur->_prev = newnode;

			++_size;

			return iterator(newnode);
		}

		iterator insert(iterator pos, T&& x)
		{
			Node* cur = pos._node;
			Node* newnode = new Node(forward<T>(x));

			Node* prev = cur->_prev;

			// prev newnode cur
			prev->_next = newnode;
			newnode->_prev = prev;

			newnode->_next = cur;
			cur->_prev = newnode;

			++_size;

			return iterator(newnode);
		}

		iterator erase(iterator pos)
		{
			Node* cur = pos._node;
			Node* prev = cur->_prev;
			Node* next = cur->_next;

			delete cur;
			prev->_next = next;
			next->_prev = prev;

			--_size;

			return iterator(next);
		}

		size_t size()
		{
			return _size;
		}

	private:
		Node* _head;
		size_t _size;
	};

为了实现万能引用，模拟实现的list中分别实现左值和右值的insert和push_back。如下：

iterator insert(iterator pos, const T& x)

iterator insert(iterator pos, T&& x)

void push_back(const T& x)

​​​​​​​void push_back(T&& x)