C++11

C++11的发展历史

        C++11是C++的第二个重要版本，并且是自C++98之后总重要的一次更新。它引入了大量更改，标准化了已有实践，并改进了对C++程序员可用的抽象。在它最终由ISO在2011年8月12日采纳前，人们曾使用名称“C++ 0x”，因为它曾被期待在2010年之前发布。C++03与C++11期间花了8年时间，故而这是迄今为止最长的版本间隔。从那之后，C++就有规律的每三年更新一次。

列表初始化

C++98传统的{}

        C++98中一般数组和结构体可以用{}进行初始化。

struct Point
{
	int _x;
	int _y;
};

int main()
{
    //数组元素初始化
	int array1[] = { 1,2,3,4,5 };
	int array2[] = { 0 };
	//隐式类型转换 {1，2}
	Point p = { 1,2 };
	return 0;
}

C++11中的{}

• C++11以后想统一初始化方式，试图实现一切对象皆可用{}初始化，{}初始化也叫做列表初始化。
• 内置类型支持，自定义类型也支持，自定义类型本质是类型转换，中间会产生临时变量对象，最后优化了以后变成直接构造。
• {}初始化的火锅城过程中，可以省略掉 = 。
• C++11列表初始化的本意是想实现一个大一统的初始化方式，要与类中构造函数的初始化列表区分开。其次在有些场景下带来的不少便利，如容器 push / insert 多参数构造的对象时，{}初始化会很方便。

#include<iostream>
#include<vector>
using namespace std;

struct Point
{
	int _x;
	int _y;
};

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

	Date(const Date& d)
		:_year(d._year)
		,_month(d._month)
		,_day(d._day)
	{
		cout << "Date(const Date& d)" << endl;
	}

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

// ⼀切皆可⽤列表初始化，且可以不加=
int main()
{
	//C++98支持的
	int a1[] = { 1,2,3,4,5 };
	int a2[5] = { 0 };
	Point p = { 1,2 };

	//C++11支持的
	//1.内置类型支持的

	int x1 = { 2 };            //等价于int x1 = 2;

	//2.自定义类型支持的

	Date d1 = { 2025,1,1 };	
	//这里本质是先用{ 2025,1,1 }构造了一个Date类型的临时对象。
	//然后临时对象再去拷贝构造d1，vs2019编译器优化后合二为一变成{ 2025,1,1 }直接构造初始化。

	const Date& d2 = { 2024,12,6 };
	//这里是d2引用的{ 2024,12,6 }构造带临时对象。

	Date d3 = { 2025 };
	Date d4 = 2025;
	//需要注意的是C++98支持单参数类型转换时可以不用加{}。

	//可以省略掉=的类型
	Point p1{ 1,2 };
	int x2{ 2 };
	Date d6{ 2024,1,22 };
	const Date& d7{ 2024,1,22 };
	//不支持 Date d6 2025; 只有{}初始化才能省略=。

	vector<Date> v;
	v.push_back(d1);							//有名对象传参
	v.push_back(Date(2025, 1, 1));		//匿名对象传参
	// 比起有名对象和匿名对象传参，列表初始化{}更有性价比。
	v.push_back({ 2025, 1, 1 });			//列表初始化传参
	return 0;
}

C++11中的std::initializer_list

• 上面的初始化已经很方便，但是对象容器的初始化还是不太方便，比如一个vector对象，我想用N个值去构造初始化，那么我们得实现很多个构造函数才能支持。
• C++11库中提出了一个std::initializer_list的类，
  auto il = { 10, 20, 30 }; // the type of il is an initializer_list，
  这个类的本质是底层开一个数组，将数据拷贝过来，std::initializer_list内部有两个指针分别指向数组的开始和结束。
• initializer_list 文档，std::initializer_list支持迭代器遍历
• 容器支持一个std::initializer_list的构造函数，也就支持任意多个元素构成的{x1,x2,x3……}进行初始化。STL中的容器支持任意多个值构成的{x1,x2,x3……}进行初始化，就是通过std::initializer_list的构造函数支持的。

//STL中的容器都增加了一个initializer_list的构造
vector(initializer_list<value_type> il, const allocator_type& alloc = allocator_type());
list(initializer_list<value_type> il, const allocator_type& alloc =	allocator_type());
map(initializer_list<value_type> il, const key_compare& comp =	key_compare(), const allocator_type& alloc = allocator_type());

template<class T>
class vector
{
public:
	typedef T* iterator;
	vector(initializer_list<T> l)
	{
		for (auto e : l)
			push_back(e);
	}
private:
	iterator _start = nullptr;
	iterator _finish = nullptr;
	iterator _endofstorage = nullptr;
};

//另外，容器的赋值也支持initializer_list的版本
vector& operator=(initializer_list<value_type> il);
map& operator=(initializer_list<value_type> il);

 initializer_list的用法：

#include<iostream>
#include<vector>
#include<string>
#include<map>
using namespace std;

int main()
{
	std::initializer_list<int> mylist;
	mylist = { 10,20,30 };
	cout << sizeof(mylist) << endl;

	//这里begin和end返回的值initializer_list对象中存的两个指针
	//这两个指针的值跟i的地址很接近，说明数组存在栈上
	int i = 0;
	cout << mylist.begin() << endl;
	cout << mylist.end() << endl;
	cout << &i << endl;

	//{}列表中可以有任意多个元素
	//这两个写法语义上还是有差别的，v1是直接构造，
	//v2是构造临时对象+临时对象拷贝v2 -> 优化为直接构造,
	// v3是对构造的临时对象的引用，因为临时对象具有常性，所以引用加const。
	vector<int> v1({ 1,2,3,4,5 });
	vector<int> v2 = { 1,2,3,4,5 };
	const vector<int>& v3 = { 1,2,3,4,5 };

	//这里是pair对象的{}初始化和map的initializer_list构造结合到一起使用。
	map<string, string> dict = { {"sort", "排序"}, {"string", "字符串"} };

	// initializer_list版本的赋值支持
	v1 = { 10,20,30,40,50 };

	return 0;
}

右值引用和移动语义

        C++98的C++语法中就有引用的语法，而C++11中新增了右值引用语法特性，C++11之后我们之前学习的引用就叫做左值引用。无论是左值引用还是右值引用，都是给对象取别名。

左值和右值

• 左值是一个表示数据的表达式（如变量名或解引用的指针），一般是有持久状态，存储在内存中，我们可以获取它的地址，左值可以出现在赋值符号的左边，也可以出现在赋值符号的右边。定义时const修饰后的左值，不能赋值，但可以取地址。
• 右值也是一个数据的表达式，要么是字面常量、要么是表达式求值过程中创建的临时对象等，右值可以出现在赋值符号的右边，但是不能出现在赋值符号的左边，右值不能取地址。
• 值得一提的是，左值的英文简写为lvalue，右值的英文简写是rvalue。传统认为他们是left value和right value的缩写。现代C++中，lvalue被解释为locator value的缩写，可意为存储在内存中、有明确存储地址且可以取地址的对象，而rvalue被解释为 read value ，指的是那些可以提供数据值，但是不可以寻址，例如：临时变量，字面量常量，存储与寄存器中的变量等，也就是说左值和右值的核心区别就是能否取地址。

#include<iostream>
using namespace std;
int main()
{
	//左值：可以取地址
	//以下的p、b、c、*p、s、s[0]就是常见的左值。
	int* p = new int(0);
	int b = 1;
	const int c = b;
	*p = 10;
	string s("111111");
	s[0] = 'x';

	cout << &c << endl;
	cout << (void*)&s[0] << endl;

	//右值：不能取地址
	double x = 1.1, y = 2.2;
	//以下几个10、x+y、fmin(x,y)、string("11111")都是常见的右值
	10;
	x + y;
	fmin(x, y);
	string("11111");

	return 0;
}

左值引用和右值引用

•  Type& r1 = x;    Type&& rr1 = y;
  第⼀个语句就是左值引用，左值引用就是给左值取别名，第二个就是右值引用，同样的道理，右值引用就是给右值取别名。
• 左值引用不能直接引用右值，但是const左值引用可以引用右值。
• 右值引用不能直接引用左值，但是右值引用可以引用move(左值)。
• template <class T> typename remove_reference<T>::type&& move (T&& arg);
• move是库里面的一个函数模板，本质内部是进行强制类型转换，当然它还涉及一些引用折叠的知识，这个后面会详细讲解。
• 需要注意的是变量表达式都是左值属性，也就意味着一个右值被右值引用绑定后，右值引用变量表达式的属性是左值。
• 语法层面看左值引用和右值引用都是取别名，不开空间。从汇编底层的角度看下面代码中r1和rr1汇编层实现，底层都是用指针实现的，没什么区别。底层汇编等实现和上层语法表达的意义有时是背道而驰的，所以不要混在一起理解，互相佐证，这样反而是陷入迷途。

#include<iostream>
using namespace std;
int main()
{
	//左值：可以取地址
	//以下的p、b、c、*p、s、s[0]就是常见的左值。
	int* p = new int(0);
	int b = 1;
	const int c = b;
	*p = 10;
	string s("111111");
	s[0] = 'x';

	cout << &c << endl;
	cout << (void*)&s[0] << endl;

	//右值：不能取地址
	double x = 1.1, y = 2.2;
	//以下几个10、x+y、fmin(x,y)、string("11111")都是常见的右值
	10;
	x + y;
	fmin(x, y);
	string("11111");

	// 左值引⽤给左值取别名
	int& r1 = b;
	int*& r2 = p;
	int& r3 = *p;
	string& r4 = s;
	char& r5 = s[0];

	// 右值引⽤给右值取别名
	int&& rr1 = 10;
	double&& rr2 = x + y;
	double&& rr3 = fmin(x, y);
	string&& rr4 = string("11111");

	// 左值引用不能直接引用右值，但是const左值引用可以引用右值
	const int& rx1 = 10;
	const double& rx2 = x + y;
	const double& rx3 = fmin(x, y);
	const string& rx4 = string("11111");

	// 右值引用不能直接引用左值，但是右值引用可以引用move(左值)
	int&& rrx1 = move(b);
	int*&& rrx2 = move(p);
	int&& rrx3 = move(*p);
	string&& rrx4 = move(s);
    //本质上就是右值的强制类型转换
	string&& rrx5 = (string&&)s;

	// b、r1、rr1都是变量表达式，都是左值
	cout << &b << endl;
	cout << &r1 << endl;
	cout << &rr1 << endl;

	// 这⾥要注意的是，rr1的属性是左值，所以不能再被右值引用绑定，除⾮move⼀下
	int& r6 = r1;
	// int&& rrx6 = rr1;
	int&& rrx6 = move(rr1);
	return 0;
}

 引用延长生命周期

        右值引用可用于为临时对象延长声明周期，const的左值引用也能延长临时对象的生存期，但是这些对象无法被修改。

#include<iostream>
using namespace std;
int main()
{
	string s1 = "Test";
	//string&& r1 = s1;        //错误：不能绑定到左值

	const string& r2 = s1 + s1;   //const的左值引用延长生命周期
	// r2 += "Test";                   //错误：const修饰的左值引用变量不可修改

	string&& r3 = s1 + s1;         //右值引用延长生命周期
	r3 += "Test";                       //能通过非const的引用修改

	return 0;
}

左值和右值的参数匹配

• C++98中，我们实现了一个const左值引用作为参数的函数，那么实参传递作之和右值都可以匹配。
• C++11以后，分别重载左值引用、const左值引用、右值引用作为形参的的Fun函数，那么实参是左值会匹配 Fun(左值引用)，实参是const左值会匹配的 Func(const 左值引用)，实参是右值会匹配的 Func(右值引用)。
• 右值引用变量在用于表达式时，属性是左值，这个设计初见会感觉很怪，下一小节我们会在讲右值引用的使用场景时体会到这样设计的价值。

#include<iostream>
using namespace std;

void Fun(int& x)
{
	cout << "左值引用重载(Fun(" << x << "))"<<endl;
}
void Fun(const int& x)
{
	cout << "const修饰的左值引用重载(Fun(" << x << "))" << endl;
}
void Fun(int&& x)
{
	cout << "右值引用重载(Fun(" << x << "))" << endl;
}

int main()
{
	int i = 1;
	const int ci = 2;

	Fun(i); // 调⽤ f(int&)
	Fun(ci); // 调⽤ f(const int&)
	Fun(3); // 调⽤ f(int&&)，如果没有 f(int&&) 重载则会调⽤ f(const int&)
	Fun(std::move(i)); // 调⽤ f(int&&)

	// 右值引⽤变量在⽤于表达式时是左值
	int&& x = 1;
	Fun(x); // 调⽤ f(int& x)
	Fun(std::move(x)); // 调⽤ f(int&& x)
	return 0;
}

右值引用和移动语义的使用场景 

左值引用的主要使用场景回顾

        左值引用主要使用场景式在函数中左值引用传参和左值引用传返回值时减少拷贝，同时还可以修改实参和修改返回对象的价值。左值引用已经解决大多数场景的拷贝效率问题，但是有些场景不能使用传左值引用返回，如addStings和generate函数，C++98的解决方案只能是被迫使用输出型参数解决。那么C++11以后这里可以使用右值引用做返回值解决吗？显然是不能的，因为这里的本质是返回对象是一个局部对象，函数结束时这个对象就析构销毁了，右值引用也无法解决对象已经析构销毁的事实。

class Solution {
public:
	// 传值返回需要拷⻉
	string addStrings(string num1, string num2) {
		string str;
		int end1 = num1.size() - 1, end2 = num2.size() - 1;
		// 进位
		int next = 0;
		while (end1 >= 0 || end2 >= 0)
		{
			int val1 = end1 >= 0 ? num1[end1--] - '0' : 0;
			int val2 = end2 >= 0 ? num2[end2--] - '0' : 0;
			int ret = val1 + val2 + next;
			next = ret / 10;
			ret = ret % 10;
			str += ('0' + ret);
		} 
		if(next == 1)
			str += '1';
		reverse(str.begin(), str.end());
		return str;
	}
};
class Solution {
public:
	// 这⾥的传值返回拷⻉代价就太⼤了
	vector<vector<int>> generate(int numRows) {
		vector<vector<int>> vv(numRows);
		for (int i = 0; i < numRows; ++i)
		{
			vv[i].resize(i + 1, 1);
		} 
		for (int i = 2; i < numRows; ++i)
		{
			for (int j = 1; j < i; ++j)
			{
				vv[i][j] = vv[i - 1][j] + vv[i - 1][j - 1];
			}
		} 
		return vv;
	}
};

移动构造和移动赋值

• 移动构造函数是一种构造函数，类似拷贝构造函数，移动构造函数要求第一个参数是该类的类型的引用，但是不同的是要求这个参数是右值引用，如果还有其他参数，额外的参数必须有缺省值。
• 移动赋值是一个赋值运算符的重载，他跟拷贝赋值构成函数重载，类似拷贝赋值函数，移动赋值函数要求第一个参数是该类的类型的引用，但不同的是要求这个参数是右值引用。
• 对于想string/vector这样的深拷贝的类或者包含深拷贝的成员变量的类来说，移动构造和移动赋值才有意义，因为移动构造和移动赋值的第一个参数都是右值引用的类型，本质是要“窃取”引用的右值对象的资源，而不是想拷贝构造和拷贝赋值那样去拷贝资源，从而提高了效率。下面的zy::string样例模拟实现了string的移动构造和移动赋值，我们需要结合场景来理解。

namespace zy
{
	class string
	{
	public:
		typedef char* iterator;
		typedef const char* const_iterator;
		iterator begin()
		{
			return _str;
		} 
		iterator end()
		{
			return _str + _size;
		} 
		const_iterator begin() const
		{
			return _str;
		} 
		const_iterator end() const
		{
			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);
		} 
		void swap(string& s)
		{
			::swap(_str, s._str);
			::swap(_size, s._size);
			::swap(_capacity, s._capacity);
		}
		string(const string& s)
			:_str(nullptr)
		{
			cout << "string(const string& s) -- 拷⻉构造" << endl;
			reserve(s._capacity);
			for (auto ch : s)
			{
				push_back(ch);
			}
		}
		// 移动构造
			string(string && s)
		{
			cout << "string(string&& s) -- 移动构造" << endl;
			swap(s);
		} 
		string& operator=(const string& s)
		{
			cout << "string& operator=(const string& s) -- 拷⻉赋值" <<
				endl;
			if (this != &s)
			{
				_str[0] = '\0';
				_size = 0;
				reserve(s._capacity);
				for (auto ch : s)
				{
					push_back(ch);
				}
			} 
			return* this;
		} 
		// 移动赋值
			string & operator=(string && s)
		{
			cout << "string& operator=(string&& s) -- 移动赋值" << endl;
			swap(s);
			return *this;
		} 
		~string()
		{
			cout << "~string() -- 析构" << endl;
			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];
				if (_str)
				{
					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)
		{
			push_back(ch);
			return *this;
		} 
		const char* c_str() const
		{
			return _str;
		}
		size_t size() const
		{
			return _size;
		}
	private:
		char* _str = nullptr;
		size_t _size = 0;
		size_t _capacity = 0;
	};
}

int main()
{
	zy::string s1("xxxxx");
	// 拷⻉构造
	zy::string s2 = s1;
	// 构造+移动构造，优化后直接构造
	zy::string s3 = zy::string("yyyyy");
	// 移动构造
	zy::string s4 = move(s1);
	cout << "******************************" << endl;
	return 0;
}

右值引用和移动语义解决传值返回问题 

namespace bit
{	
    string addStrings(string num1, string num2)
	{
		string str;
		int end1 = num1.size() - 1, end2 = num2.size() - 1;
		int next = 0;
		while (end1 >= 0 || end2 >= 0)
		{
			int val1 = end1 >= 0 ? num1[end1--] - '0' : 0;
			int val2 = end2 >= 0 ? num2[end2--] - '0' : 0;
			int ret = val1 + val2 + next;
			next = ret / 10;
			ret = ret % 10;
			str += ('0' + ret);
		}
		if (next == 1)
			str += '1';
		reverse(str.begin(), str.end());
		cout << "******************************" << endl;
		return str;
	}
}
// 场景1
int main()
{
	zy::string ret = zy::addStrings("11111", "2222");
	cout << ret.c_str() << endl;
	return 0;
} 
// 场景2
int main()
{
	zy::string ret;
	ret = zy::addStrings("11111", "2222");
	cout << ret.c_str() << endl;
	return 0;
}

右值对象构造，只有拷贝构造，没有移动构造的场景

• 图1展示了vs2019 debug环境下编译器对拷贝的优化，左边为不优化的情况下，两次构造，右边为编译器优化的场景下连续步骤中的拷贝合二为一，变为依次拷贝构造。
• 需要注意的是在 vs2019 的 release 和 vs2022 的 debug 和 release，下面代码优化为非常恐怖，会直接将str对象的构造，str拷贝构造临时对象，临时对象拷贝构造ret对象，合三为一，变为直接构造。变为直接构造。要理解这个优化要结合局部对象生命周期和栈帧的角度理解，如图3所示。
• linux下可以将下面代码拷贝到test.cpp文件，编译时使用g++ test.cpp -fno-elide-constructors的方式关闭构造优化，运行结果可以看到图1左边没有优化的两次拷贝。

 图1

右值对象构造，有拷贝构造，也有移动构造的场景

•  图2展示了vs2019 debug环境下编译器对拷贝的优化，左边为不优化的情况下，两次移动构造，右边为编译器优化的情况下连续步骤中的拷贝合二为一，变为移动构造。
• 需要注意的是在 vs2019 的 release 和 vs2022 的 debug 和 release ，下面代码优化会非常恐怖，会直接将str对象的构造，str对象的拷贝构造临时对象，临时对象拷贝构造ret对象，合三为一，变为直接构造。要理解这个优化要结合局部对象生命周期和栈帧的角度理解，如图3所示。
• linux下可以将下面代码拷贝到test.cpp文件，编译时使用g++ test.cpp -fno-elide-constructors的方式关闭构造优化，运行结果可以看到图2左边没有优化的两次移动。

图2 

图3 

右侧对象赋值，只有拷贝构造和拷贝赋值，没有移动构造和移动赋值的场景 

• 图4展示了linux下vs2019 debug 和 g++ test.cpp -fno-elide-constructors的方式关闭构造优化环境下的编译器处理，运行结果为一次拷贝构造，依次拷贝赋值。
• 需要注意的是 在vs2019的release和vs2022的debug和release，下面代码会进一步优化，直接构造要返回的临时对象，str本质是临时对象的引用，底层角度用指针实现。运行结果的角度，我们可以看到str的析构是在赋值以后，说明str就是临时对象的别名。

图4 

 右值对象赋值，既有拷贝构造和拷贝赋值，也有移动构造和移动赋值的场景

• 图5左边展示了vs2019 debug和 g++ test.cpp -fno-elide-constructors 关闭优化环境
  下编译器的处理，⼀次移动构造，⼀次移动赋值。
• 需要注意的是在vs2019的release和vs2022的debug和release，下⾯代码会进⼀步优化，直接构造要返回的临时对象，str本质是临时对象的引用，底层角度用指针实现。运行结果的角度，我们可以看到str的析构是在赋值以后，说明str就是临时对象的别名。
  

图5 

 右值引用和移动语义在传参中的提效

• 查看STL文档我们发现C++11以后容器的push和insert系列的接口增加了右值引用版本。
• 当实参是左值时，容器内部继续调用拷贝构造进行拷贝，将对象拷贝到容器空间中的对象上。
• 当实参是右值时，容器内部则调用移动构造，右值对象的资源会移动到容器空间的对象上。
• 把我们之前模拟实现的zy::list拷贝过来，实现支持右值引用参数版本的push_back和insert。
• 其实这里还有一个emplace系列的接口，但是涉及可变参数模板，我们需要把可变参数模板讲解以后在讲解emplace系列的接口。

list.h
// 以下代码为了控制课件篇幅，把跟这⾥⽆关的接⼝都删除了
namespace zy
{
	template<class T>
	struct ListNode
	{
		ListNode<T>* _next;
		ListNode<T>* _prev;
		T _data;
		ListNode(const T& data = T())
			:_next(nullptr)
			, _prev(nullptr)
			, _data(data)
		{}
		ListNode(T&& data)
			:_next(nullptr)
			, _prev(nullptr)
			, _data(move(data))
		{}
	};
	template<class T, class Ref, class Ptr>
	struct ListIterator
	{
		typedef ListNode<T> Node;
		typedef ListIterator<T, Ref, Ptr> Self;
		Node* _node;
		ListIterator(Node* node)
			:_node(node)
		{}
		Self& operator++()
		{
			_node = _node->_next;
			return *this;
		} 
		Ref operator*()
		{
			return _node->_data;
		}
		bool operator!=(const Self& it)
		{
			return _node != it._node;
		}
	};
	template<class T>
	class list
	{
		typedef ListNode<T> Node;
	public:
		typedef ListIterator<T, T&, T*> iterator;
		typedef ListIterator<T, const T&, const T*> const_iterator;
		iterator begin()
		{
			return iterator(_head->_next);
		} 
		iterator end()
		{
			return iterator(_head);
		} 
		void empty_init()
		{
			_head = new Node();
			_head->_next = _head;
			_head->_prev = _head;
		} 
		list()
		{
			empty_init();
		} 
		void push_back(const T& x)
		{
			insert(end(), x);
		} 
		void push_back(T&& x)
		{
			insert(end(), move(x));
		}
		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;
			return iterator(newnode);
		} 
		iterator insert(iterator pos, T && x)
		{
			Node* cur = pos._node;
			Node* newnode = new Node(move(x));
			Node* prev = cur->_prev;
			// prev newnode cur
			prev->_next = newnode;
			newnode->_prev = prev;
			newnode->_next = cur;
			cur->_prev = newnode;
			return iterator(newnode);
		}
	private:
		Node* _head;
	};
}

Test.cpp
#include"list.h"
// void push_back (const value_type& val);
// void push_back (value_type&& val);
// iterator insert (const_iterator position, value_type&& val);
// iterator insert (const_iterator position, const value_type& val);

int main()
{
	zy::list<zy::string> lt;
	cout << "*************************" << endl;
	zy::string s1("111111111111111111111");
	lt.push_back(s1);
	cout << "*************************" << endl;
	lt.push_back(zy::string("22222222222222222222222222222"));
	cout << "*************************" << endl;

	lt.push_back("3333333333333333333333333333");
	cout << "*************************" << endl;
	lt.push_back(move(s1));
	cout << "*************************" << endl;
	return 0;
}

类型分类

• C++11以后，进一步对类型进行了划分，右值被划分为纯右值(pure value，简称prvalue)和将亡值(expiring value，简称xvalue)。
• 纯右值是指那些字面值常量或求值结果相当于字面值或是一个不具名的临时对象。如：42、true、nullptr或者类似str.substr(1, 2)、str1+str2等传值返回函数调用，或者整型a、b、a++、a+b等。纯右值和将亡值是C++11中提出的，C++11中的纯右值概念划分等价于C++98中的右值。
• 将亡值是指返回右值引用的函数的调用表达式和转换为右值引用的转换函数的调用表达，如move(x)、static_cast<X&&>(x)。
• 泛左值(generalized value，简称glvalue)，泛左值包含将亡值和左值。
• 值类别 - cppreference.com和Value categories这两个分别是关于值类型的中文和英文文档，有兴趣的可以了解一下。

引用折叠

• C++中不能直接定义引用的引用，如：int& && r = i; ，这样写会直接报错，通过模板或者typedef中的类型操作可以构成引用的引用。
• 通过模板或typedef中的类型操作可以构成引用的引用时，这时C++11给出了一个引用折叠的规则；右值引用的右值引用为右值引用，其他所有组合的引用折叠均为左值引用。
• 下面的程序很好的展示了模板和typedef时构成引用的引用时的引用折叠规则，大家需要一个一个仔细理解一下。向f2这样的函数模板中，T&& x 参数看起来是右值引用参数，但是由于引用折叠的规则，它传递左值时就是左值引用，传递右值时就是右值引用，有些地方也把这种函数模板叫做万能引用。
• Function(T&& t) 函数模板程序中，假设实参是int右值，模板参数T推导为int；实参是int左值，模板参数T推导为int&，再结合引用折叠规则，就实现了实参是左值，实例化出左值引用版本形参的Function，实参是右值，实例化出右值引用版本形参的Function。

// 由于引⽤折叠限定，f1实例化以后总是⼀个左值引⽤
template<class T>
void f1(T& x)
{}
// 由于引⽤折叠限定，f2实例化后可以是左值引⽤，也可以是右值引⽤
template<class T>
void f2(T&& x)
{}
int main()
{
	typedef int& lref;
	typedef int&& rref;
	int n = 0;
	lref& r1 = n; // r1 的类型是 int&
	lref&& r2 = n; // r2 的类型是 int&
	rref& r3 = n; // r3 的类型是 int&
	rref&& r4 = 1; // r4 的类型是 int&&
	// 没有折叠->实例化为void f1(int& x)
	f1<int>(n);
	f1<int>(0); // 报错
	// 折叠->实例化为void f1(int& x)
	f1<int&>(n);
	f1<int&>(0); // 报错
	// 折叠->实例化为void f1(int& x)
	f1<int&&>(n);
	f1<int&&>(0); // 报错
	// 折叠->实例化为void f1(const int& x)
	f1<const int&>(n);
	f1<const int&>(0);
	// 折叠->实例化为void f1(const int& x)
	f1<const int&&>(n);
	f1<const int&&>(0);
	// 没有折叠->实例化为void f2(int&& x)
	f2<int>(n); // 报错
	f2<int>(0);
	// 折叠->实例化为void f2(int& x)
	f2<int&>(n);
	f2<int&>(0); // 报错
	// 折叠->实例化为void f2(int&& x)
	f2<int&&>(n); // 报错
	f2<int&&>(0);
	return 0;
}

template<class T>
void Function(T&& t)
{
	int a = 0;
	T x = a;
	//x++;
	cout << &a << endl;
	cout << &x << endl << endl;
} 
int main()
{
	// 10是右值，推导出T为int，模板实例化为void Function(int&& t)
	Function(10); // 右值
	int a;
	// a是左值，推导出T为int&，引⽤折叠，模板实例化为void Function(int& t)
	Function(a); // 左值
	// std::move(a)是右值，推导出T为int，模板实例化为void Function(int&& t)
	Function(std::move(a)); // 右值
	const int b = 8;
	// a是左值，推导出T为const int&，引⽤折叠，模板实例化为void Function(const int&t)
	// 所以Function内部会编译报错，x不能++
	Function(b); // const 左值
	// std::move(b)右值，推导出T为const int，模板实例化为void Function(const int&&t)
	// 所以Function内部会编译报错，x不能++
	Function(std::move(b)); // const 右值
	return 0;
}

 完美转发

• Function(T&& x)函数模板程序中，传左值实例化以后是左值引用的Function函数，传右值实例化以后是右值引用的Function函数。
• 但是结合我们在讲解的变量表达式都是左值属性，也就意味着一个右值被右值引用绑定后，右值引用变量表达式的属性是左值，也就是说Function函数中t的属性是左值，那么我们把t传递给下一层函数Func，那么匹配的都是左值引用版本的Fun函数。这里我们想要保持t对象的属性，就需要使用完美转发实现。
• template <class T> T&& forward (typename remove_reference<T>::type&arg);
• template <class T> T&& forward (typenameremove_reference<T>::type&& arg)；
• 完美转发forward本质是一个函数模板，它主要还是通过引用折叠的方式实现，下面实例中传递给Function的实参是右值，T推导为int，没有折叠，forward内部t被强转为右值引用返回；传递给Function的实参是左值，T被推导为int&，引用折叠为左值引用，forward内部被强转为左值引用返回。

template <class _Ty>
_Ty&& forward(remove_reference_t<_Ty>& _Arg) noexcept
{ // forward an lvalue as either an lvalue or an rvalue
	return static_cast<_Ty&&>(_Arg);
} 
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<class T>
void Function(T&& t)
{
	Fun(t);
	//Fun(forward<T>(t));
} 
int main()
{
	// 10是右值，推导出T为int，模板实例化为void Function(int&& t)
	Function(10); // 右值
	int a;
	// a是左值，推导出T为int&，引⽤折叠，模板实例化为void Function(int& t)
	Function(a); // 左值
	// std::move(a)是右值，推导出T为int，模板实例化为void Function(int&& t)
	Function(std::move(a)); // 右值
	const int b = 8;
	// a是左值，推导出T为const int&，引⽤折叠，模板实例化为void Function(const int&t)
	Function(b); // const 左值
	// std::move(b)右值，推导出T为const int，模板实例化为void Function(const int&&t)
	Function(std::move(b)); // const 右值
	return 0;
}