【C++11】列表初始化、右值引用和移动语义、引用折叠、完美转发

一.C++的发展历史

1. 1998年，C++标准委员会成立。C++98是C++的第一个国际标准，标志着C++语言的成熟和稳定，并计划每五年对C++标准进行一次更新。
2. C++03是对C++98的微小修订，没有引入重大新特性。
3. C++11是C++的第⼆个重要版本，并且是从C++98起的最重要的更新。C++11的发布对C++语言的发展产生了深远的影响，它使得C++语言更加现代化和高效，提高了开发者的编程体验和代码质量。
4. 在C++11由ISO在2011年8月12日采纳前，人们曾使用名称"C++0x"，因为它曾被期待在2010年之前发布（由于C++标准委员会长期摆烂，导致五年计划延期）。经过多年的延期和讨论，C++标准委员会终于在2011年完成了新标准的制定，并将新标准命名为C++11。
5. C++03与C++11期间花了8年时间，故而这是迄今为止最长的版本间隔。从那时起，C++有规律地每3年更新一次。

1. 非官方文档
2. 官方中文文档
3. 官方英文文档

说明：第一个链接不是C++官方文档，标准也只更新到C++11，但是以头文件形式呈现，内容比较易看好懂。后两个链接分别是C++官方文档的中文版和英文版，信息很全，更新到了最新的C++标准，但是相比第一个不那么易看；几个文档各有优势，可以结合着使用。

二.列表初始化

1.C++98的{}

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

struct Point
{int _x;int _y;
};int main()
{int arr1[] = { 1, 2, 3, 4, 5 };int arr2[5] = { 0 };Point p = { 1, 2 };return 0;
}

2.C++11的{}

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

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：//内置类型支持列表初始化int x = { 2 }; //低层就是int x = 2; 无区别//自定义类型也支持列表初始化//本质是用{2025, 1, 4}构造一个Date临时对象//临时对象再去拷贝构造1，编译器优化为合二为一变成{2025, 1, 4}直接构造初始化d1//运行可以验证上面的理论，发现没有调用拷贝构造Date d1 = { 2025, 1, 4 }; //C++11：多参数构造函数支持隐式类型转换//这里d2引用的是{2025, 1, 5}构造的临时对象，临时对象具有常性，需要加上const//匿名对象是手动创建的，临时对象是编译器生成的，二者都具有常性，引用时都需要加上constconst Date& d2 = { 2025, 1, 5 };//C++98支持单参数的隐式类型转换，也可以不用{}Date d3 = { 2025 };Date d4 = 2025;string s = "1111";//列表初始化：可以省略掉=Point p1{ 1, 2 };int x2{ 2 };Date d6{ 2025, 1, 6 };const Date& d7{ 2025, 1, 6 };//不支持以下，只有列表初始化，才能省略= //Date d8 2025;vector<Date> v;v.push_back(d1);v.push_back(Date(2025, 1, 1));//比起有名对象和匿名对象传参，这里{}更有性价比v.push_back({ 2025, 1, 1 });map<string, int> dict;dict.insert({ "123",123 });return 0;
}

3.C++11中的std::initializer_list

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

int main()
{initializer_list<int> il = { 1,2,3,4,5,6,7,8,9 };auto it = il.begin();while (it != il.end()){cout << *it << " ";++it;}cout << endl;cout << il.size() << endl;//构造+拷贝构造：优化为直接构造vector<int> v1 = { 1,2,3,4,5,6,7,8,9 };const vector<int>& v2 = { 1,2,3,4,5,6,7,8,9 };const vector<int>& v3{ 1,2,3,4,5,6,7,8,9 };//构造：单参数(initializer_list参数)支持隐式类型转换vector<int> v4({ 1,2,3,4,5,6,7,8,9 });//内部多参数隐式类型转换构造pair临时对象，外部单参数隐式类型转换构造initializer_list临时对象，最后拷贝构造：优化为直接构造map<string, string> dict = { {"aaa","bbb"},{"ccc","ddd"},{"eee","fff"} };return 0;
}

三.右值引用和移动语义

C++98中的引用就叫做左值引用，而C++11提供了右值引用。无论左值引用还是右值引用，都是给对象取别名。

1.左值和右值

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

int main()
{//左值：可以取地址 //以下的 p、b、c、*p、s、s[0] 就是常见的左值int* p = new int(10);int b = 10;const int c = b;*p = 20;string s("1111");s[0] = 'x'; //operator[]函数调用：返回引用//*p在堆区，其余的都在栈区cout << &p << endl; cout << &b << endl;cout << &c << endl;cout << &(*p) << endl; cout << &s << endl;cout << (void*)&s[0] << endl; //需要强转，否则输出的是字符串int x = 1, y = 2;//右值：不可以取地址//以下的 10、x + y、fmin(x, y)、string("11111") 都是常见的右值10; //字面量常量x + y; //返回临时对象min(x, y); //返回临时对象string("1111"); //匿名对象//cout << &10 << endl;//cout << &(x + y) << endl;//cout << &(min(x, y)) << endl;//cout << &string("1111") << endl;return 0;
}

2.左值引用和右值引用

1. Type& r1 = x; Type&& rr1 = y; 第一个语句就是左值引用，左值引用就是给左值取别名，第⼆个就是右值引用，右值引用就是给右值取别名。
2. 左值引用不能直接引用右值，但是const左值引用可以引用右值。
3. 右值引用不能直接引用左值，但是右值引用可以引用move(左值)。
4. move是库里面的一个函数模板，本质内部是进行强制类型转换，当然他还涉及一些引用折叠的知
   识。
   
5. 需要注意的是变量表达式都是左值属性，也就意味着一个右值被右值引用绑定后，右值引用变量的属性是左值。
6. 语法层面看，左值引用和右值引用都是取别名，不开空间。从汇编底层的角度看下面代码中r1和rr1汇编层实现，底层都是用指针实现的，可以取地址，左值引用和右值引用都是左值。底层汇编等实现和上层语法表达的意义有时是背离的，所以不要然到一起去理解，互相佐证，这样反而是陷入迷途。语法是语法，低层是低层。
7. 面试题：左值引用和右值引用的最终目的都是减少拷贝和提高效率。左值引用还可以修改参数/返回值，方便使用。左值引用的不足之处：部分函数返回场景，只能传值返回，不能左值引用返回。当前函数的局部对象，出了当前函数作用域生命周期到了，就销毁了，不能左值引用返回，只能传值返回。

//move的低层实现
//template <class _Ty>
//remove_reference_t<_Ty>&& move(_Ty&& _Arg)
//{ 
//	//forward _Arg as movable
//	return static_cast<remove_reference_t<_Ty>&&>(_Arg);
//}//const引用：既可以传左值，也可以传右值
template<class T>
void Func(const T& x)
{}int main()
{//左值int* p = new int(10);int b = 10;const int c = b;*p = 20;string s("11111");s[0] = 'x';double x = 1.1, y = 1.1;//左值引用给左值取别名int& r1 = b;int*& r2 = p;int& r3 = *p;string& r4 = s;char& r5 = s[0];//const int& r6 = c; 这里存在权限问题，需要加上const//右值引用给右值取别名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);  //注意：move后b还是左值int*&& rrx2 = move(p);int&& rrx3 = move(*p);string&& rrx4 = move(s);     //move的低层就是强制类型转换string&& rrx5 = (string&&)s; //左值引用、右值引用，只要是引用，低层都是指针，可以强转//b、r1、rr1都是变量表达式，都是左值 cout << &b << endl;cout << &r1 << endl;cout << &rr1 << endl;//这里要注意的是，rr1的属性是左值，所以不能再被右值引用绑定，除非move一下 int& r6 = r1;int&& rrx6 = move(rr1); //错误写法：int&& rrx6 = rr1;//结论：左值引用的属性是左值，右值引用的属性也是左值//原因：只要是引用，低层都是指针，都可以取地址，所以是左值return 0;
}

3.引用延长生命周期

临时对象的生命周期只在当前这一行代码中。右值引用可用于为临时对象延长生命周期，const的左值引用也能延长临时对象的生命周期，但这些对象无法被修改。

int main()
{string s1 = "abandon";//string&& r1 = s1; //错误：右值引用不能引用左值const string& r2 = s1 + s1; //const的左值引用直接引用右值（临时对象），延长声明周期，r2销毁了，临时对象才销毁//r2 += "abandon" //错误：不能修改const的引用string&& r3 = s1 + s1; //右值引用直接引用右值，延长声明周期r3 += "abandon"; //可以修改非const的引用return 0;
}

4.左值和右值的参数匹配

1. C++98中，我们实现一个const左值引用作为参数的函数，那么实参传递左值和右值都可以匹配。
2. C++11以后，分别重载左值引用、const左值引用、右值引用作为形参的fun函数，那么实参是左值会匹配fun（左值引用），实参是const左值会匹配fun（const左值引用），实参是右值会匹配fun（右值引用），总结编译器会找最匹配的调用。
3. 右值引用变量在用于表达式时属性是左值，这个设计这里会感觉跟怪，讲右值引用的使用场景时，就能体会这样设计的价值了。

void fun(int& x)
{cout << "左值引用重载fun(" << x << ")\n";
}void fun(const int& x)
{cout << "const的左值引用重载fun(" << x << ")\n";
}void fun(int&& x)
{cout << "右值引用重载fun(" << x << ")\n";
}int main()
{int i = 1;const int ci = 2;fun(i);   //调用fun(int&) fun(ci);  //调用fun(const int&) fun(3);   //调用fun(int&&)。如果没有fun(int&&)，重载则会调用fun(const int&) fun(move(i)); //调用fun(int&&) //右值引用变量在用于表达式时是左值//右值引用本身的属性是左值，右值本身不能修改，但是被右值引用后就可以修改int&& x = 1;fun(x);       //调用fun(int& x) fun(move(x)); //调用fun(int&& x)return 0;
}

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

1.左值引用使用场景

1. 左值引用主要使用场景是在函数中const左值引用传参，参数可以是右值和左值引用传参和传返回值时减少拷贝，同时还可以修改实参和修改返回对象的价值。
2. 左值引用已经解决大多数场景的拷贝效率问题，但是有些场景不能使用法传左值引用返回，如addStrings和generate函数（若返回左值引用，导致类似野指针的问题）

• 解决方案一：不用返回值，用输出型参数（牺牲了可读性）
• 解决方案二：编译器的优化（非标准，不同的编译器可能优化不同）
• 解决方案三：新标准、新语法（右值引用和移动语义）

//传值返回需要拷贝
string addStrings(string num1, string num2)
{int cur1 = num1.size() - 1, cur2 = num2.size() - 1;int carry = 0; //记录进位的值：0/1string ret;while (cur1 >= 0 || cur2 >= 0 || carry){int sum = carry; //记录两数之和if (cur1 >= 0) {sum += (num1[cur1] - '0'); //先加上第一个字符串cur1--;}if (cur2 >= 0){sum += (num2[cur2] - '0'); //再加上第二个字符串cur2--;}ret += ((sum % 10) + '0'); //尾插个位值carry = sum / 10; //更新进位值}reverse(ret.begin(), ret.end()); //逆序得到结果return ret;
}//这里的传值返回拷贝代价就太⼤了 
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;
}//利用输出型参数解决问题
void _generate(int numRows, vector<vector<int>>& vv);

3. 那么C++11以后这里可以使用右值引用做返回值解决吗？显然是不可能的，因为这里的本质是返回对象是一个局部对象，函数结束这个对象就析构销毁了，右值引用返回也无法改变对象已经析构销毁的事实。

2.移动构造和移动赋值

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

namespace xzy
{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);}string(const string& s):_str(nullptr){cout << "string(const string& s) -- 拷贝构造" << endl;reserve(s._capacity);for (auto ch : s){push_back(ch);}}void swap(string& s){std::swap(_str, s._str);std::swap(_size, s._size);std::swap(_capacity, s._capacity);}//移动构造string(string&& s){cout << "string(string&& s) -- 移动构造" << endl;swap(s); //右值为临时对象、匿名对象，迟早是要销毁的，不如将资源交给我，之后再销毁//右值引用的属性之所以是左值，是因为需要修改（转移资源）//如果s的属性是右值，就无法进行swap}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()
{xzy::string s1 = "123";//拷贝构造xzy::string s2 = s1;//构造+移动构造：优化后直接构造xzy::string s3 = xzy::string("123");//移动构造xzy::string s4 = move(s1); //此时s1中的资源被s4夺走了return 0;
}

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

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

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

图一：

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

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

图二：

图三：

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

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

图4：

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

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

图5：

总结：对于深拷贝的自定义类型：如vector/string/map…，实现移动构造和移动赋值有很大的价值。对于浅拷贝的自定义类型：如Date/pair<int, int>…，不需要实现移动构造和移动赋值，此时编译器的优化有很大的价值。

6.类型分类

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

7.引用折叠

1. C++中不能直接定义引用的引用如int& && r = i;，这样写会直接报错，通过模板或 typedef 中的类型操作可以构成引用的引用。
2. 通过模板或 typedef 中的类型操作可以构成引用的引用时，这时C++11给出了一个引用折叠的规则：右值引用的右值引用折叠成右值引用，所有其它组合均折叠成左值引用。
3. 下面的程序中很好的展示了模板和 typedef 时构成引用的引用时的引用折叠规则。
4. 像f2这样的函数模板中，T&& x参数看起来是右值引用参数，但是由于引用折叠的规则，它传递左值时就是左值引用，传递右值时就是右值引用，有些地方也把这种函数模板的参数叫做万能引用。

//由于引用折叠的限制，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 = 0;  // 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;
}

5. Function(T&& t)函数模板程序中，假设实参是int右值，模板参数T的推导int，实参是int左值，模板参数T的推导int&，再结合引用折叠规则，就实现了实参是左值，实例化出左值引用版本形参的Function，实参是右值，实例化出右值引用版本形参的Function。

//万能引用模版：一般不需要传入T，由编译器自动推导类型。传入左值就是左值引用，传入右值就是右值引用
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);   //左值//move(a)是右值，推导出T为int，模版实例化为 void Function(int&& t)Function(move(a));  //右值const int b = 1;//b是左值，推导出T为const int&，引用折叠，模板实例化为void Function(const int& t)//Function内部会编译报错，x不能++Function(b);  //const 左值//move(b)右值，推导出T为const int，模板实例化为void Function(const int&& t)//Function内部会编译报错，x不能++ Function(move(b));  //const 右值return 0;
}

8.完美转发

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

//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); //由于右值引用的自身属性是左值，所以不管t是左值引用/右值引用，Fun函数匹配的都是左值引用Fun(forward<T>(t));
}int main()
{Function(10);int a;Function(a);Function(move(a));const int b = 1;Function(b);Function(move(b));return 0;
}

以下是链表插入时引入移动语义，减少拷贝，提高效率：

namespace xzy
{template<class T>struct list_node{T _data;list_node<T>* _next;list_node<T>* _prev;左值版本//list_node(const T& data = T())//	:_data(data)//	,_next(nullptr)//	,_prev(nullptr)//{}右值版本//list_node(T&& data)//	:_data(forward<T>(data))//	, _next(nullptr)//	, _prev(nullptr)//{}list_node() = default;//万能引用template<class X>list_node(X&& data):_data(forward<X>(data)), _next(nullptr), _prev(nullptr){}};template<class T, class Ref, class Ptr>struct list_iterator{typedef list_node<T> Node;Node* _node;list_iterator(Node* node):_node(node){}};template<class T>class list{typedef list_node<T> Node;public:typedef list_iterator<T, T&, T*> iterator;iterator begin(){return _head->_next;}iterator end(){return _head;}list(){_head = new Node;_head->_next = _head;_head->_prev = _head;_size = 0;}左值版本//void push_back(const T& x)//{//	insert(end(), x);//}右值版本//void push_back(T&& x)//{//	insert(end(), forward<T>(x)); //x一定是左值，此时需要完美转发//}//万能引用template<class X>void push_back(X&& x){insert(end(), forward<X>(x)); //x一定是左值，此时需要完美转发}左值版本//iterator insert(iterator pos, const T& x)//{//	Node* cur = pos._node;//	Node* prev = cur->_prev;//	Node* newnode = new Node(x);//	newnode->_next = cur;//	cur->_prev = newnode;//	newnode->_prev = prev;//	prev->_next = newnode;//	++_size;//	return newnode;//}右值版本//iterator insert(iterator pos, T&& x)//{//	Node* cur = pos._node;//	Node* prev = cur->_prev;//	Node* newnode = new Node(forward<T>(x));//	newnode->_next = cur;//	cur->_prev = newnode;//	newnode->_prev = prev;//	prev->_next = newnode;//	++_size;//	return newnode;//}//万能引用template<class X>iterator insert(iterator pos, X&& x){Node* cur = pos._node;Node* prev = cur->_prev;Node* newnode = new Node(forward<X>(x));newnode->_next = cur;cur->_prev = newnode;newnode->_prev = prev;prev->_next = newnode;++_size;return newnode;}private:Node* _head;size_t _size;};
}int main()
{xzy::list<xzy::string> lt;xzy::string s1("111");lt.push_back(s1);xzy::string s2("222");lt.push_back(move(s2));lt.push_back("333");return 0;
}