C++11语法介绍(1) -- 列表初始化{}，左值和右值，右值引用和移动语义，引用折叠，完美转发

1.C++11的发展时间线

2.列表初始化

2.1C++98传统的{}

2.2C++11中的{}

2.3C++11中的std::initializer_list

2.3.1vector中initializer list构造的模拟实现

2.3.2以vector为例演示initializer_list版本的构造

3.右值引用和移动语义

3.1左值和右值

3.2左值引用和右值引用

3.3引用延长生命周期

3.4左值和右值的参数匹配

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

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

3.5.2移动构造和移动赋值

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

3.5.3.1右值进行构造，只有拷贝构造，没有移动构造的场景

3.5.3.2右值进行拷贝，有拷贝构造，也有移动构造

3.5.3.3右值进行赋值，只有拷贝构造和拷贝赋值，没有移动构造和移动赋值的场景

3.5.3.4右值进行赋值，既有拷贝构造和拷贝赋值，也有移动构造和移动赋值的场景

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

3.6类型分类

3.7引用折叠

3.8完美转发

1.C++11的发展时间线

C++11 是 C++ 的第⼆个主要版本，并且是从 C++98 起的最重要更新。它引⼊了⼤量更改，标准化了既有实践，并改进了对 C++ 程序员可⽤的抽象。在它最终由 ISO 在 2011 年 8 ⽉ 12 ⽇采纳前，⼈们曾使⽤名称“C++0x”，因为它曾被期待在 2010 年之前发布。C++03 与 C++11 期间花了 8 年时间，故⽽这是迄今为⽌最⻓的版本间隔。从那时起，C++ 有规律地每 3 年更新⼀次。

2.列表初始化

2.1C++98传统的{}

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

2.2C++11中的{}

C++11是想统一初始化方式，试图实现⼀切对象皆可⽤{}初始化，{}初始化也叫做列表初始化。内置类型⽀持，⾃定义类型也⽀持。{}初始化的过程中，可以省略掉=。在有些场景下带来的不少便利，如容器push/inset多参数构造的对象时，{}初始化会很⽅便。

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++11⽀持的//1. 内置类型⽀持int x1 = { 2 };//2. ⾃定义类型⽀持//本质是先构建一个临时对象，然后再拷贝构造d1//编译器优化后合二为一变成使用{2025, 1, 1}直接构造d1Date d1 = { 2025, 1, 1 };cout << endl;//d2引用的是{2024, 7, 25}构造的临时对象，临时对象具有常性，所以只能用const对象进行引用const Date& d2 = { 2024, 7, 25 };// 需要注意的是C++98⽀持单参数时类型转换，也可以不⽤{}，但是必须加'='Date d3 = { 2025 };	//C++11Date d4 = 2025;		//C++98 -- 将整型转换为Date类型string str = "1111";	//C++98 -- 将char*类型转换为string类型//3. 可以省略掉=int x2{ 2 };Date d6{ 2024, 7, 25 };const Date& d7{ 2024, 7, 25 };return 0;
}

这里以vector<Date>为例子，介绍有名对象传参，匿名对象传参以及列表初始化传参的情况，vector的push_back是深拷贝，在进行传参的时候会有一次拷贝构造。

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()
{//vector的push_back实现的是深拷贝，插入一个对象时要先拷贝出一个对象再进行插入vector<Date> v;//有名对象传参 -- 拷贝构造Date d1 = { 2025, 1, 1 };cout << endl;v.push_back(d1);	cout << endl;//匿名对象传参 -- 先构造一个临时对象(匿名对象)，最后通过匿名对象进行拷贝构造v.push_back(Date(2025, 1, 1));	cout << endl;//列表初始化传参 -- 先构造出一个临时对象，通过临时对象进行拷贝构造v.push_back({ 2025, 1, 1 });	cout << endl;return 0;
}

这里需要注意的是在vs2022中，vector的扩容机制是插入一个元素扩容一次，所以这里每次插入都会将其前面存储的元素进行一次拷贝构造。所以通过上面可以看出，不管是匿名对象传参还是列表初始化传参本质上都是先构造一个临时对象，然后再传参时调用一次拷贝构造。

2.3C++11中的std::initializer_list

上面的初始化已经很方便了，但是对于对象容器的初始化还是不太方便，比如一个vector对象，想用3个值去构造初始化，就需要一个3个参数的构造函数，想用5个值取构造初始化，就需要一个5个参数的构造函数，这样在使用的时候就要写成下列的样子vector<int> v1(1,2,3);vector<int> v2(1,2,3,4,5).

所以C++11库中提出了⼀个std::initializer_list的类，这个类的本质是在底层开一个数组，将数据拷贝过来，std::initializer_list内部有两个指针,分别指向数组的开始和结束.

容器(如vector)支持通过一个std::initializer_list对象进行构造的构造函数,就能支持不同数量的值进行初始化.

容器的赋值也支持initializer_list的版本

2.3.1vector中initializer list构造的模拟实现

其实这个构造函数的实现非常简单，就是依次遍历initializer list对象中的元素进行插入即可。

template<class T>
class vector
{
public:typedef T* iterator;vector(initializer_list<T> l){for (auto e : l){push_back(e);}}void push_back(const T& x){//尾插逻辑的实现}
private:iterator _start = nullptr;iterator _finish = nullptr;iterator _end_of_storage = nullptr;
};

2.3.2以vector为例演示initializer_list版本的构造

int main()
{initializer_list<int> mylist;mylist = { 10, 20, 30 };cout << sizeof(mylist) << endl;	//initializer_list对象中只存储了两个指针
}

这里因为是在64位系统下，一个指针是8个字节，所以里面存储了两个指针，对齐后输出的结果是16.

下面的代码验证了该对象的两个指针是存储在栈上的：

int main()
{// 这⾥begin和end返回的值initializer_list对象中存的两个指针// 这两个指针的值跟i的地址跟接近，说明数组存在栈上int i = 0;initializer_list<int> mylist;mylist = { 10, 20, 30 };cout << mylist.begin() << endl;cout << mylist.end() << endl;cout << &i << endl;return 0;
}

int main()
{// 这两个写法语义上还是有差别的// v1是先通过{1,2,3,4,5}调用了initializer_list的默认构造，//构造了一个initializer_list的临时对象，再用这个临时对象调//用initializer_list版本的vector的构造函数构造出v1// v2是先通过{1,2,3,4,5}调用了initializer_list的默认构造，//构造了一个initializer_list的临时对象，再用这个临时对象调//用vector的initializer_list版本的构造函数，构造一个vector//的临时对象，再用这个vector的临时对象调用vector的拷贝构造，//构造出v2,编译器这里直接优化为了initializer_list版本的构造vector<int> v1({ 1,2,3,4,5 });vector<int> v2 = { 1,2,3,4,5 };return 0;
}

这里在vector的层面上，第一个就是直接调用了initalizer_list版本的构造函数进行了直接构造，构造出v1。第二个就是先调用了initializer_list般的的构造函数构造出一个vector的临时对象，再用这个vector的临时对象调用拷贝构造构造出v2。

3.右值引用和移动语义

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

3.1左值和右值

左值是⼀个表⽰数据的表达式(如变量名或解引⽤的指针)，⼀般是有持久状态，存储在内存中，我们可以获取它的地址，左值可以出现赋值符号的左边，也可以出现在赋值符号右边。定义时const修饰符后的左值，不能给他赋值，但是可以取它的地址。

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

注意：这里对s[0]取地址时要强转为void*或者是其他的指针类型，不然这里的流插入会打印出string对象的内容。

右值也是⼀个表⽰数据的表达式，要么是字⾯值常量、要么是表达式求值过程中创建的临时对象等，右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能取地址。

int main()
{// 右值：不能取地址double x = 1.1, y = 2.2;// 以下⼏个10、x + y、fmin(x, y)、string("11111")都是常⻅的右值10;x + y;fmin(x, y);string("11111");//cout << &10 << endl;//cout << &(x+y) << endl;//cout << &(fmin(x, y)) << endl;//cout << &string("11111") << endl;return 0;
}

左值的英⽂简写为lvalue，右值的英⽂简写为rvalue。传统认为它们分别是leftvalue、right value 的缩写。现代C++中，lvalue被解释为loactor value的缩写，可意为存储在内存中、有明确存储地址可以取地址的对象，⽽ rvalue 被解释为 read value，指的是那些可以提供数据值，但是不可以寻址，例如：临时变量，字⾯量常量，存储于寄存器中的变量等。也就是说左值和右值的核⼼区别就是能否取地址。

3.2左值引用和右值引用

1. Type& r1 = x; Type&& rr1 = y; 第⼀个语句就是左值引⽤，左值引⽤就是给左值取别名，第⼆个就是右值引⽤，同样的道理，右值引⽤就是给右值取别名。

int main()
{int a = 1;int& ra = a;	//左值引用int&& rra = 1;	//右值引用return 0;
}

2.左值引用不能直接引用右值，但是const左值引用可以引用右值。

3.右值引用不能直接引用左值，但是右值引用可以引用move(左值)。

int main()
{int a = 1;double b1 = 1.1, b2 = 2.2;int& r = a;					//左值引用const double& cr = b1 + b2;	//const左值引用引用右值double&& rr1 = b1 + b2;		//右值引用int&& rr2 = move(a);		//右值引用引用move(左值)return 0;
}

4.move是库里面的一个函数模板。本质是进行强制类型转换，将其转换为右值，这里简单的了解一下。

5.需要注意的是变量表达式都是左值属性，也就意味着一个右值被右值引用绑定之后，右值引用变量这个变量表达式的属性是左值。

6.语法层面看，左值引用和右值引用都是取别名，不另外开空间。从汇编底层的角度看下面代码中的r和rr汇编层实现，底层都是用指针实现的，没有区别。底层汇编的实现和上层cpp表达的指针在这里别弄混淆了，这里别管汇编底层，简单的理解左值引用和右值引用就是给变量取别名，他们的大小都是一样的。

int main()
{string s = "1111";string& r = s;string&& rr = move(s);cout << &s << endl;cout << &r << endl;cout << &rr << endl;cout << sizeof(s) << endl;cout << sizeof(r) << endl;cout << sizeof(rr) << endl;return 0;
}

这里这个右值引用变量是可以取到地址的，所以不管是什么变量，只要是变量都是左值属性。

注：左值引用是给变量取别名，所以这里左值引用变量r的地址和变量a的地址是一样的，右值引用也是给变量取别名，所以这里右值引用变量rr和a的地址也是一样的。

3.3引用延长生命周期

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

int main()
{string s1 = "xiaoc";//这里s1 + s1是临时对象，生命周期只有当前这一行//左值引用不能引用临时对象//string& r1 = s1 + s1;//const左值引用可以引用临时对象，延长了临时对象生命周期 -- 在该作用域的后面行也能用const string& r2 = s1 + s1;	cout << r2 << endl;//但是const左值引用变量不能被修改//r2 += s1;//右值引用引用临时对象，延长了临时对象生命周期 -- 在该作用域的后面行也能用string&& rr1 = s1 + s1;cout << rr1 << endl;//右值引用变量可以被修改rr1 += s1;cout << rr1 << endl;//const右值引用引用临时对象，延长了临时对象生命周期 -- 在该作用域的后面行也能用const string&& rr2 = s1 + s1;cout << rr2 << endl;//const右值引用变量不可以被修改//rr2 += s1;return 0;
}

右值引用就算引用的是一个不可被修改的对象(临时对象等)，右值引用变量都能进行修改。

3.4左值和右值的参数匹配

C++98中，我们实现一个const左值引用作为参数的函数，那么实参传递左值或右值都可以匹配。

C++11以后，分别重载左值引用，const左值引用，右值引用作为形参的f函数，那么实参是左值会匹配f(左值引用)，实参是const左值会匹配f(const左值引用)，实参是右值会匹配f(右值引用)。

void f(int& x)
{cout << "左值引用重载f(" << x << ")\n";
}
void f(const int& x)
{cout << "const左值引用重载f(" << x << ")\n";
}
void f(int&& x)
{cout << "右值引用重载f(" << x << ")\n";
}int main()
{int i = 1;const int ci = 2;f(i);		// 调⽤ f(int&)f(ci);		// 调⽤ f(const int&)f(3);		// 调⽤ f(int&&)，如果没有 f(int&&) 重载则会调⽤ f(const int&)f(move(i));	// 调⽤ f(int&&)，如果没有 f(int&&) 重载则会调⽤ f(const int&)return 0;
}

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

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

左值引⽤主要使⽤场景是在函数中左值引⽤传参和左值引⽤传返回值时减少拷⻉，同时还可以修改实参和修改返回对象。左值引⽤已经解决⼤多数场景的拷⻉效率问题，但是有些场景不能使⽤传左值引⽤返回，如addString函数。这里返回的是一个局部对象，当该函数栈帧销毁之后，局部对象也要销毁，不管是左值返回还是右值返回对不能将局部对象进行返回，只能使用传值返回。C++98中的解决⽅案只能是被迫使⽤输出型参数解决。

左值引用的不足是部分函数返回值的场景(当前函数局部对象出了当前函数作用域就销毁的场景)，只能传值返回，不能左值引用返回(比如下面的addString函数)。

class Solution
{
public://传值返回需要拷贝string addString(string num1, string num2){string str;int end1 = num1.size() - 1;int 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;}
};

3.5.2移动构造和移动赋值

移动构造函数是⼀种构造函数，类似拷⻉构造函数，移动构造函数要求第⼀个参数是该类类型的引⽤，但是不同的是要求这个参数是右值引⽤，如果还有其他参数，额外的参数必须有缺省值。

移动赋值是⼀个赋值运算符的重载，他跟拷⻉赋值构成函数重载，类似拷⻉赋值函数，移动赋值函数要求第⼀个参数是该类类型的引⽤，但是不同的是要求这个参数是右值引用。

对于像string/vector这样的深拷⻉的类或者包含深拷⻉的成员变量的类，移动构造和移动赋值才有意义，因为移动构造和移动赋值的第⼀个参数都是右值引⽤的类型，他的本质是要“窃取”引⽤的右值对象的资源，⽽不是像拷⻉构造和拷⻉赋值那样去拷⻉资源，从提⾼效率。右值一般是临时对象和匿名对象，是马上要销毁的对象，所以这里直接用右值引用进行资源的掠夺是合理的。下⾯的xiao::string样例实现了移动构造和移动赋值，需要结合场景理解。

//string.h
#pragma once
#include <iostream>
#include <assert.h>
using namespace std;namespace xiaoc
{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){std::swap(_str, s._str);std::swap(_size, s._size);std::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;};
}

#include "string.h"int main()
{//构造xiaoc::string s1("xxxx");cout << endl;//拷贝构造xiaoc::string s2 = s1;cout << endl;//构造一个临时对象，然后再用进行移动构造s3 -> 优化后直接构造xiaoc::string s3 = xiaoc::string("yyyy");cout << endl;//移动构造xiaoc::string s4 = move(s1);cout << endl;return 0;
}

这里第三个是构造是因为编译器进行了优化，将狗改造一个临时对象再用临时对象移动构造s3直接优化为了构造s3.

这里通过移动构造用s1构造s6时，对s1进行了资源的抢夺。所以一个左值不要随便进行move，不然就有了右值的属性，就有可能通过右值引用之后对其资源进行掠夺。

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

这里不是将上述代码的返回值直接修改为右值引用来解决传值返回时拷贝的问题，这里是在string类中添加移动构造和移动赋值的默认成员函数来进行减少拷贝的。本质就是将调用拷贝构造和拷贝赋值的地方改为调用移动构造和移动赋值，通过掠夺返回的局部对象的资源来构造对象，而不是拷贝构造和拷贝赋值一样进行深拷贝。具体看下面的对比介绍。

3.5.3.1右值进行构造，只有拷贝构造，没有移动构造的场景

第一张图表示在编译器没有优化的情况下，进行传值返回，首先要用局部对象拷贝构造出一个临时对象，然后再用该临时对象拷贝构造出ret对象。 Linux下在编译时加上 -fno-elide-constructors选项可以关闭构造的优化，所以可以看到下面没有进行优化的结果。

第二张图在vs2019Debug模式下，进行了一层优化，优化掉了中间的临时对象，str对象直接调用拷贝构造，构造出ret对象，由于当前机器没有vs2019，该部分在此就没有进行演示了。

第三张图在vs2022Debug模式下，进行了两层优化，直接构造出了ret对象。这里可以理解为str时ret的引用，所以从始至终都是对一个对象进行处理，并没有拷贝构造新的对象。打印str和ret的地址，可以发现str和ret的地址是一样的。

这里编译器把传值传参的拷贝构造也优化了，可以理解为前两个构造是将传值传参的构造临时对象和临时对象的拷贝构造优化为了一个构造。第三个构造是ret的构造。

3.5.3.2右值进行拷贝，有拷贝构造，也有移动构造

这里和只有拷贝构造的时候一样，只是将拷贝构造的地方换成了移动构造，这里str是一个局部对象，按道理来说应该是一个左值，但是编译器会自动识别str是一个将亡值，意思就是编译器会认为它是右值，所以这里调用的是移动构造，而不是拷贝构造。这里就不一一演示了，下图为第一张图没有优化的结果。

3.5.3.3右值进行赋值，只有拷贝构造和拷贝赋值，没有移动构造和移动赋值的场景

将上面调用的代码改为如下代码就是调用赋值。

int main()
{xiaoc::string ret;ret = Solution().addString("1111", "2222");cout << ret.c_str() << endl;return 0;
}

第一张图是没有进行优化的结果，这里还是先通过str调用拷贝构造构造出一个临时对象，再用临时对象进行拷贝赋值。

第二张图是进行了一层优化的结果，没有构造str对象，直接就是构造的临时对象，这里的str相当于是临时对象的别名，再通过临时对象拷贝赋值给ret。

3.5.3.4右值进行赋值，既有拷贝构造和拷贝赋值，也有移动构造和移动赋值的场景

第一张图和只有拷贝构造和拷贝赋值的时候是一样的，只不过把拷贝构造和拷贝赋值换成了移动构造和移动赋值。 下图是第一张图的结果。

第二张图也是进行了一层优化，没有构造出str对象，直接构造临时对象，临时对象调用移动赋值给了ret对象。 下面是第二张图的结果。

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

STL文档在C++11之后，容器的push和insert接口增加了右值引用传参的版本。当实参是一个左值时，容器内部还是调用拷贝构造进行拷贝，将对象拷贝到容器空间中的对象。当实参是一个右值，容器内部则调用移动构造，右值对象的资源被转移到容器空间的对象上。

3.6类型分类

C++11之后，进一步对左值和右值的类型进行了划分，右值被划分纯右值(prvalue)和将亡值(xvalue)。

纯右值是指那些字面值常量或求值结果，相当于字面量或是一个没有名称的临时变量。如：20，true，nullptr或者是s1 + s2这样的表达式等。C++11中的纯右值等价于C++98中的右值。

将亡值是指返回右值引用的函数的调用表达式和转换为右值引用的转换函数调用表达式，如：move(x)，static_cast<int&&>(x)。将亡值就是有名字的右值。

泛左值(glvalue)包含将亡值和左值，泛左值就是有名字的值。

3.7引用折叠

1.C++中不能直接定义引用的引用(如：int& && r = i)，这样写会直接报错，但是通过模板或者typedef中的类型操作可以构成引用的引用。

2.通过模板或typedef中的类型操作可以构成引用的引用，这时C++11给出一个引用折叠的规则：右值引用的右值引用折叠成右值引用，所以其他组合均折叠成左值引用。

int main()
{int& && r = i;return 0;
}

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&&return 0;
}

3.像f2这样的函数模板中，T&& x参数看起来是右值引用参数，但是由于引用折叠的规则，传递左值时就是左值引用，传递右值时就是右值引用，有些地方也把这种函数模板的参数叫做万能引用。

4.Function(T&& x)函数模板程序中，假设实参是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()
{int n = 0;//没有折叠->实例化为void f1(int& x)f1<int>(n);//f1<int>(0);	//报错 -- void f1(int& x)不能接收右值	//折叠->实例化为void f1(int& x)f1<int&>(n);//f1<int&>(0);	//报错 -- void f1(int& x)不能接收右值	// 折叠->实例化为void f1(int& x)f1<int&&>(n);//f1<int&&>(0);	//报错 -- void f1(int& x)不能接收右值	// 折叠->实例化为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 f1(const int& x)f1<const int&&>(n);f1<const int&&>(0);// 没有折叠->实例化为void f2(int&& x)//f2<int>(n);	//报错 -- void f2(int&& x)不能接收左值f2<int>(0);// 折叠->实例化为void f2(int& x)f2<int&>(n);//f2<int&>(0);  //报错 -- void f2(int& x)不能接收右值// 折叠->实例化为void f2(int&& x)//f2<int&&>(n); // 报错 -- void f2(int&& x)不能接收左值f2<int&&>(0);return 0;
}

template<class T>
void Function(T&& t)
{int n = 0;T x = n;//x++;cout << &n << endl;cout << &x << endl << endl;
}
int main()
{// 10是右值，推导出T为int，模板实例化为void Function(int&& t)// T为int，所以函数中的x类型是int，x和n的地址不一样Function(10);int a;// a是左值，推导出T为int&，引⽤折叠，模板实例化为void Function(int& t)// T为int&，所以函数中x是n的左值引用变量，x和n的地址一样Function(a);// std::move(a)是右值，推导出T为int，模板实例化为void Function(int&& t)// T为int，所以函数中的x类型是int，x和n的地址不一样Function(std::move(a));const int b = 8;// b是左值，推导出T为const int&，引⽤折叠，模板实例化为void Function(const int& t)// 所以x不能++// T为int&，所以函数中x是n的左值引用变量，x和n的地址一样Function(b);// std::move(b)是右值，推导出T为const int，模板实例化为void Function(const int&& t)// 所以x不能++// T为int，所以函数中的x类型是int，x和n的地址不一样Function(std::move(b));return 0;
}

3.8完美转发

Function(T&& t)函数模板程序中，传左值实例化以后是左值引用的Function函数，传右值实例化以后是右值引用的Function函数。

但是，变量表达式都是左值属性，也就意味着一个右值被右值引用引用之后，该右值引用变量表达式的属性是左值，也就是说Function函数中的t的属性是左值，那么如果在Function函数中还有一个Fun函数，把t传给Fun，匹配的都是左值引用版本的Fun函数。这里如果想要保持t对象的属性，就需要使用完美转发实现。

完美转发forward本质是一个函数模板，他主要还是通过引用折叠的方法实现。

template <class T> 
T&& forward(typename remove_reference<T>::type& arg);template <class T> 
T&& forward(typename remove_reference<T>::type&& arg);

下面以Function函数和Fun函数为例进行演示：

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()
{Function(10);int a;Function(a);Function(std::move(a));const int b = 8;Function(b);Function(std::move(b));return 0;
}

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()
{Function(10);int a;Function(a);Function(std::move(a));const int b = 8;Function(b);Function(std::move(b));return 0;
}