注：这个是博主复习使用的专题，仅适用于自己以及学习过C++知识点的同学
文章目录
[1.1. C++98传统的{}](#1.1. C++98传统的{})
[1.2. C++11中的{}](#1.2. C++11中的{})
[1.3. C++11中的std::initalizer_list](#1.3. C++11中的std::initalizer_list)
[2.1. 左值和右值](#2.1. 左值和右值)
[2.1.1. 左值](#2.1.1. 左值)
[2.1.2. 右值](#2.1.2. 右值)
[2.2. 左值引用和右值引用](#2.2. 左值引用和右值引用)
[2.2.1. 左值引用](#2.2.1. 左值引用)
[2.2.2. 右值引用](#2.2.2. 右值引用)
[2.2.3. 左值引用可以引用右值？](#2.2.3. 左值引用可以引用右值？)
[2.2.4. 右值引用可以引用左值吗？](#2.2.4. 右值引用可以引用左值吗？)
[2.3. 右值引用使用场景和意义](#2.3. 右值引用使用场景和意义)
[2.3.1. 左值引用的使用场景](#2.3.1. 左值引用的使用场景)
[2.3.2. 左值引用的短板](#2.3.2. 左值引用的短板)
[2.3.3. 右值引用和移动语义](#2.3.3. 右值引用和移动语义)
[2.3.4. 右值引用引用左值](#2.3.4. 右值引用引用左值)
[2.3.5. 右值引用的其他使用场景](#2.3.5. 右值引用的其他使用场景)
[4.1. 万能引用](#4.1. 万能引用)
[4.2. 完美转发保持值的属性](#4.2. 完美转发保持值的属性)
前言
注：这个是博主复习使用的专题，仅适用于自己以及学习过C++知识点的同学。
思维导图：
一、列表初始化
1.1. C++98传统的{}
C++98中一般数据和结构体都可以用{}进行初始化。
cpp
struct Point
{
int x;
int y;
};
int main()
{
int arr[] = { 1,2,3,4,5,6 };
struct Point p = { 1,2 };
return 0;
}1.2. C++11中的{}
- C++11以后，试图实现一切对象皆可用{}初始化，{}初始化也叫做列表初始化。
- 内置类型支持，自定义类型也支持，自定义类型本质是类型转换，中间是产生临时变量，最后优化成直接构造
- {}初始化的过程中，可以省略=
cpp
#include<iostream>
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()
{
int x1 = { 1 };
int x2{ 2 };
int arr[]{ 1,2,3,4,5 };
int arr2[]{ 0 };
Point p{ 1,2 };
int* p1 = new int[4] {0};
int* p2 = new int[4] {1, 2, 3, 4};
Date d1{ 2026,2,14 };
Date d2 = { 2026,2,14 };
return 0;
}1.3. C++11中的std::initalizer_list
C++11中新增了initializer_list容器，该容器没有提供过多的成员函数。
- 提供了begin和end函数，用于支持迭代器遍历。
- 以及size函数支持获取容器中的元素个数。
initializer_list本质就是一个大括号括起来的列表，如果用auto关键字定义一个变量来接收一个大括号括起来的列表，然后以**typeid(变量名).name()**的方式查看该变量的类型，此时会发现该变量的类型就是initializer_list。
cpp
int main()
{
auto l = { 1,2,3,4,5 };
cout << typeid(l).name() << endl; // class std::initializer_list<int>
return 0;
}initializer_list容器没有提供对应的增删查改等接口，因为initializer_list并不是专门用于存储数据的，而是为了让其他容器支持列表初始化的。比如：
cpp
#include<vector>
#include<map>
#include<string>
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<int> v = { 1,2,3,4,5 };
vector<Date> vd = { Date(2026,2,14), Date(2026,2,15) };
map<string, string> m{ make_pair("sort","排序"),{"insert","插入"} };
v = { 5,4,3,2,1 };
return 0;
}C++98并不支持直接用列表对容器进行初始化，这种初始化方式是在C++11引入initializer_list后才支持的。
而这些容器之所以支持使用列表进行初始化，根本原因是因为C++11给这些容器都增加了一个构造函数，这个构造函数就是以initializer_list作为参数的。
当用列表对容器进行初始化时，这个列表被识别成initializer_list类型，于是就会调用这个新增的构造函数对该容器进行初始化。
这个新增的构造函数要做的就是遍历initializer_list中的元素，然后将这些元素依次插入到要初始化的容器当中即可。
二、右值引用和移动语义
2.1. 左值和右值
2.1.1. 左值
左值是一个表示数据的表达式，如变量名或解引用的指针。是持久化的，存储在内存中的。 左值可以出现在赋值运算符 = 的左边。
- 左值可以**被取地址，**也可以被修改 (const 修饰的左值除外)。
- 左值可以出现在赋值符号的左边，也可以出现在赋值符号的右边（如字符串字面量是左值）。
cpp
int main()
{
int x = 10; // x 是左值
x = 20; // x可以修改
int* px = &x; // x可以取地址
const char* ptr = "hello world"; // ptr 和 字符串常量都是 左值
return 0;
}2.1.2. 右值
右值也是一个表示数据的表达式，如字母常量、表达式的返回值、函数的返回值（不能是左值引用返回）等等。无法取地址 的临时对象，或者是一个纯粹的字面值（除了字符串字面量）。表达式结束后就不再存在 的短暂对象。
右值通常只能出现在赋值运算符 = 的右边。
cpp
int main()
{
int x = 20;
int y = 30; // 30 是右值，它是一个字面常量，没有具体地址
y = 40; // 40 也是右值
// 10 = y; // 错误！10 是右值，不能出现在等号左边
int z = x + y; // (x + y) 的计算结果是一个临时值，它是右值
//以下几个都是常见的右值
10;
x + y;
fmin(x, y);
//错误示例（右值不能出现在赋值符号的左边）
//10 = 1;
//x + y = 1;
//fmin(x, y) = 1;
return 0;
}- 右值本质就是一个临时变量或常量值，比如代码中的10就是常量值，表达式x+y和函数fmin的返回值就是临时变量，这些都叫做右值。
- 这些临时变量和常量值并没有被实际存储起来，这也就是为什么右值不能被取地址的原因，因为只有被存储起来后才有地址。
- 但需要注意的是，这里说函数的返回值是右值，指的是传值返回的函数，因为传值返回的函数在返回对象时返回的是对象的拷贝 ，这个拷贝出来的对象就是一个临时变量。
而对于左值引用返回的函数来说，这些函数返回的是左值 。比如string类实现的[]运算符重载函数：
cpp
namespace xxhh
{
//模拟实现string类
class string
{
public:
//[]运算符重载（可读可写）
char& operator[](size_t i)
{
assert(i < _size); //检测下标的合法性
return _str[i]; //返回对应字符
}
//...
private:
char* _str; //存储字符串
size_t _size; //记录字符串当前的有效长度
//...
};
}
int main()
{
xxhh::string s("hello");
s[3] = 'x'; //引用返回，支持外部修改
return 0;
}这里的[ ]运算符重载函数返回的是一个字符的引用，因为它需要支持外部对该位置的字符进行修改，所以必须采用左值引用返回。之所以说这里返回的是一个左值，是因为这个返回的字符是被存储起来了的，是存储在string对象的_str对象当中的，因此这个字符是可以被取到地址的。
2.2. 左值引用和右值引用
2.2.1. 左值引用
左值引用就是对左值的引用，给左值取别名，通过"&"来声明。比如：
cpp
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;
}2.2.2. 右值引用
右值引用就是对右值的引用，给右值取别名，通过"&&"来声明。比如：
cpp
int main()
{
double x = 1.1, y = 2.2;
// 以下都是右值
10;
x + y;
fmin(x, y);
string("1111");
int&& rr1 = 10;
double&& rr2 = x + y;
double rr3 = fmin(x, y);
string&& rr4 = string("1111");
return 0;
}2.2.3. 左值引用可以引用右值？
- 左值引用不能引用右值，因为这涉及到权限放大的问题，右值是不能被修改的，而左值引用是可以修改的。
- 但是 const 左值引用可以引用右值，因为 const 左值引用能够保证被引用的数据不会被修改。
const 左值引用既可以引用左值，也可以引用右值。比如：
cpp
template<class T>
void Print(const T& val)
{
cout << val << endl;
}
int main()
{
int x = 10;
Print(x); // x是左值
Print(string("1111")); // string("1111")是右值
return 0;
}2.2.4. 右值引用可以引用左值吗？
-
右值引用只能引用右值，不能引用左值。
-
但是右值引用可以引用std::move以后得左值。
std::move函数是C++标准库中提供的一个函数，被 std::move后的左值能够赋值给右值引用。比如：
cpp
int main()
{
int a = 10;
int&& rra = 10;
int&& ra = std::move(a);
return 0;
}2.3. 右值引用使用场景和意义
虽然const左值引用既能接收左值，又能接收右值，但左值引用终究存在短板，而C++11提出的右值引用就是用来解决左值引用的短板的。
为了更好的说明问题，这里需要借助一个深拷贝的类，下面模拟实现了一个简化版的string类。类当中实现了一些基本的成员函数，并在string的拷贝构造函数和赋值运算符重载函数当中打印了一条提示语句，这样当调用这两个函数时我们就能够知道。
cpp
namespace xxhh
{
class string
{
public:
typedef char* iterator;
iterator begin()
{
return _str; //返回字符串中第一个字符的地址
}
iterator end()
{
return _str + _size; //返回字符串中最后一个字符的后一个字符的地址
}
//构造函数
string(const char* str = "")
{
_size = strlen(str); //初始时，字符串大小设置为字符串长度
_capacity = _size; //初始时，字符串容量设置为字符串长度
_str = new char[_capacity + 1]; //为存储字符串开辟空间（多开一个用于存放'\0'）
strcpy(_str, str); //将C字符串拷贝到已开好的空间
}
//交换两个对象的数据
void swap(string& s)
{
//调用库里的swap
::swap(_str, s._str); //交换两个对象的C字符串
::swap(_size, s._size); //交换两个对象的大小
::swap(_capacity, s._capacity); //交换两个对象的容量
}
//拷贝构造函数（现代写法）
string(const string& s)
:_str(nullptr)
, _size(0)
, _capacity(0)
{
cout << "string(const string& s) -- 深拷贝" << endl;
string tmp(s._str); //调用构造函数，构造出一个C字符串为s._str的对象
swap(tmp); //交换这两个对象
}
//赋值运算符重载（现代写法）
string& operator=(const string& s)
{
cout << "string& operator=(const string& s) -- 深拷贝" << endl;
string tmp(s); //用s拷贝构造出对象tmp
swap(tmp); //交换这两个对象
return *this; //返回左值（支持连续赋值）
}
//析构函数
~string()
{
delete[] _str; //释放_str指向的空间
_str = nullptr; //及时置空，防止非法访问
_size = 0; //大小置0
_capacity = 0; //容量置0
}
//[]运算符重载
char& operator[](size_t i)
{
assert(i < _size); //检测下标的合法性
return _str[i]; //返回对应字符
}
//改变容量，大小不变
void reserve(size_t n)
{
if (n > _capacity) //当n大于对象当前容量时才需执行操作
{
char* tmp = new char[n + 1]; //多开一个空间用于存放'\0'
strncpy(tmp, _str, _size + 1); //将对象原本的C字符串拷贝过来（包括'\0'）
delete[] _str; //释放对象原本的空间
_str = tmp; //将新开辟的空间交给_str
_capacity = n; //容量跟着改变
}
}
//尾插字符
void push_back(char ch)
{
if (_size == _capacity) //判断是否需要增容
{
reserve(_capacity == 0 ? 4 : _capacity * 2); //将容量扩大为原来的两倍
}
_str[_size] = ch; //将字符尾插到字符串
_str[_size + 1] = '\0'; //字符串后面放上'\0'
_size++; //字符串的大小加一
}
//+=运算符重载
string& operator+=(char ch)
{
push_back(ch); //尾插字符串
return *this; //返回左值（支持连续+=）
}
//返回C类型的字符串
const char* c_str()const
{
return _str;
}
private:
char* _str;
size_t _size;
size_t _capacity;
};
}2.3.1. 左值引用的使用场景
在说明左值引用的短板之前，我们先来看看左值引用的使用场景：
- 左值引用做参数，防止传参时进行拷贝操作。
- 左值引用做返回值，防止返回时对返回对象进行拷贝操作。
cpp
int main()
{
xxhh::string s("hello world");
func1(s); //值传参 会形成临时对象，然后执行string(const string& s)
func2(s); //左值引用传参
s += 'X'; //左值引用返回 X
return 0;
}因为我们模拟实现是string类的拷贝构造函数当中打印了提示语句，因此运行代码后通过程序运行结果就知道，值传参时调用了string的拷贝构造函数。
此外，因为string的+=运算符重载函数是左值引用返回的，因此在返回+=后的对象时不会调用拷贝构造函数，但如果将+=运算符重载函数改为传值返回，那么重新运行代码后你就会发现多了一次拷贝构造函数的调用。
我们都知道string的拷贝是深拷贝，深拷贝的代价是比较高的，我们应该尽量避免不必要的深拷贝操作，因此这里左值引用起到的作用还是很明显的。
2.3.2. 左值引用的短板
左值引用虽然能避免不必要的拷贝操作，但左值引用并不能完全避免。
- 左值引用做参数，能够完全避免传参时不必要的拷贝操作。
- 左值引用做返回值，并不能完全避免函数返回对象时不必要的拷贝操作。
如果函数返回的对象是一个局部对象 ，该变量出了函数作用域就被销毁了，这种情况下不能使用左值引用作为返回值 ，只能以传参的方式返回，这就是左值引用的短板。
比如下面我们模拟实现一个int版本的to_string函数，这个to_string函数就不能使用左值引用返回，因为to_string函数返回的是一个局部变量。
代码如下：
此时调用to_string函数返回时，就一定会调用string的拷贝构造函数。比如：
cpp
xxhh::string to_string(int val)
{
bool flag = true;
if (val < 0)
{
flag = false;
val = 0 - val;
}
xxhh::string str;
while (val > 0)
{
int x = val % 10;
val /= 10;
str += (x + '0');
}
if (flag == false)
{
str += '-';
}
std::reverse(str.begin(), str.end());
return str;
}此时调用to_string函数返回时，就一定会调用string的拷贝构造函数。比如：
cpp
#include<algorithm>
namespace xxhh
{
class string
{
public:
typedef char* iterator;
iterator begin()
{
return _str; //返回字符串中第一个字符的地址
}
iterator end()
{
return _str + _size; //返回字符串中最后一个字符的后一个字符的地址
}
//构造函数
string(const char* str = "")
{
_size = strlen(str); //初始时，字符串大小设置为字符串长度
_capacity = _size; //初始时，字符串容量设置为字符串长度
_str = new char[_capacity + 1]; //为存储字符串开辟空间（多开一个用于存放'\0'）
strcpy(_str, str); //将C字符串拷贝到已开好的空间
}
//交换两个对象的数据
void swap(string& s)
{
//调用库里的swap
::swap(_str, s._str); //交换两个对象的C字符串
::swap(_size, s._size); //交换两个对象的大小
::swap(_capacity, s._capacity); //交换两个对象的容量
}
//拷贝构造函数（现代写法）
string(const string& s)
:_str(nullptr)
, _size(0)
, _capacity(0)
{
cout << "string(const string& s) -- 深拷贝" << endl;
string tmp(s._str); //调用构造函数，构造出一个C字符串为s._str的对象
swap(tmp); //交换这两个对象
}
//赋值运算符重载（现代写法）
string& operator=(const string& s)
{
cout << "string& operator=(const string& s) -- 深拷贝" << endl;
string tmp(s); //用s拷贝构造出对象tmp
swap(tmp); //交换这两个对象
return *this; //返回左值（支持连续赋值）
}
//析构函数
~string()
{
delete[] _str; //释放_str指向的空间
_str = nullptr; //及时置空，防止非法访问
_size = 0; //大小置0
_capacity = 0; //容量置0
}
//[]运算符重载
char& operator[](size_t i)
{
assert(i < _size); //检测下标的合法性
return _str[i]; //返回对应字符
}
//改变容量，大小不变
void reserve(size_t n)
{
if (n > _capacity) //当n大于对象当前容量时才需执行操作
{
char* tmp = new char[n + 1]; //多开一个空间用于存放'\0'
strncpy(tmp, _str, _size + 1); //将对象原本的C字符串拷贝过来（包括'\0'）
delete[] _str; //释放对象原本的空间
_str = tmp; //将新开辟的空间交给_str
_capacity = n; //容量跟着改变
}
}
//尾插字符
void push_back(char ch)
{
if (_size == _capacity) //判断是否需要增容
{
reserve(_capacity == 0 ? 4 : _capacity * 2); //将容量扩大为原来的两倍
}
_str[_size] = ch; //将字符尾插到字符串
_str[_size + 1] = '\0'; //字符串后面放上'\0'
_size++; //字符串的大小加一
}
//+=运算符重载
string& operator+=(char ch)
{
push_back(ch); //尾插字符串
return *this; //返回左值（支持连续+=）
}
//返回C类型的字符串
const char* c_str()const
{
return _str;
}
private:
char* _str;
size_t _size;
size_t _capacity;
};
xxhh::string to_string(int val)
{
bool flag = true;
if (val < 0)
{
flag = false;
val = 0 - val;
}
xxhh::string str;
while (val > 0)
{
int x = val % 10;
val /= 10;
str += (x + '0');
}
if (flag == false)
{
str += '-';
}
std::reverse(str.begin(), str.end());
return str;
}
}
int main()
{
xxhh::string s = xxhh::to_string(123);
return 0;
}此时调用to_string函数返回时，就一定会调用string的拷贝构造函数。比如：
cpp
int main()
{
xxhh::string s = xxhh::to_string(123);
return 0;
}C++11提出右值引用就是为了解决左值引用的这个短板的，但解决方式并不是简单的将右值引用作为函数的返回值。
2.3.3. 右值引用和移动语义
右值引用和移动语句解决上述问题的方式就是，给当前模拟实现的string类增加移动构造和移动赋值方法。
移动构造
移动构造是一个构造函数，该构造函数的参数是右值引用类型的 ，移动构造的本质是将传入右值的资源窃取出来 ，避免进行深拷贝。
代码如下：
cpp
string(string&& s):_str(nullptr),_capacity(0),_size(0)
{
cout << "string(string&& s) -- 移动构造" << endl;
swap(s);
}移动构造和拷贝构造的区别：
- 在没有增加移动构造之前，由于拷贝构造采用的是 const 左值引用接收参数，因此无论拷贝构造对象传入的是左值还是右值，都会调用拷贝构造函数。
- 增加移动构造之后，由于移动构造采用的是右值引用接收参数，因此如果拷贝构造对象时传入的是右值，那么就会调用移动构造函数（最匹配原则）。
- string的拷贝构造函数做的是深拷贝，而移动构造函数中只需要调用swap函数进行资源转移，因此调用移动构造的代价要比调用拷贝构造的代价小。
给string类增加移动构造后，对于返回局部string对象的这类函数，在返回string对象时就会调用移动构造进行资源的移动，而不会再调用拷贝构造函数进行深拷贝了。比如：
cpp
int main()
{
xxhh::string s = xxhh::to_string(123);
return 0;
}说明一下：
- 虽然to_string当中返回的局部string对象是一个左值，但由于该string对象在当前函数调用结束后就会立即被销毁，我可以把这种即将被消耗的值叫做"将亡值"，比如匿名对象也可以叫做"将亡值"。
- 既然"将亡值"马上就要被销毁了，那还不如把它的资源转移给别人用，因此编译器在识别这种"将亡值"时会将其识别为右值，这样就可以匹配到参数类型为右值引用的移动构造函数。
移动赋值
移动赋值是一个赋值运算符重载函数，该函数的参数是右值引用类型的，移动赋值也是将传入右值的资源窃取过来，占为己有，这样就避免了深拷贝，所以它叫移动赋值，就是窃取别人的资源来赋值给自己的意思。
cpp
// 移动赋值
string& operator=(string&& s)
{
cout << "string& operator=(string&& s) -- 移动赋值" << endl;
swap(s);
return *this;
}移动赋值和拷贝赋值的区别：
- 在没有增加移动赋值之前，由于原有的 operator= 函数采用的是 const 左值引用接收参数，因此无论赋值时传入的是左值还是右值，都会调用原有的 operator= 函数。
- 增加移动赋值之后，由于移动赋值采用的是右值引用接收参数，因此如果赋值时传入的是右值，那么就会调用移动赋值函数（最匹配原则）。
- string原有的 operator= 函数做的是深拷贝，而移动赋值函数中只需要调用 swap 函数进行资源的转移，因此调用移动赋值的代价比调用原有 operator= 的代价小。
cpp
int main()
{
xxhh::string s;
s = xxhh::to_string(123);
return 0;
}此时当to_string函数返回局部的string对象时，会先调用移动构造生成一个临时对象，然后再调用移动赋值将临时对象的资源转移给我们接收返回值的对象，这个过程虽然调用了两个函数，但这两个函数要做的只是资源的移动，而不需要进行深拷贝，大大提高了效率。
说明一下： 在实现移动赋值函数之前，该代码的运行结果理论上应该是调用一次拷贝构造，再调用一次原有的operator=函数，但由于原有operator=函数实现时复用了拷贝构造函数，因此代码运行后的输出结果会多打印一次拷贝构造函数的调用，这是原有operator=函数内部调用的。
2.3.4. 右值引用引用左值
右值引用虽然不能引用左值，但也不是完全不可以，当需要用右值引用引用一个左值时，可以通过move函数将左值转化为右值。
move函数的名字具有迷惑性，move函数实际并不能搬移任何东西，该函数唯一的功能就是将一个左值强制转化为右值引用，然后实现移动语义。
2.3.5. 右值引用的其他使用场景
C++11标准出来之后，STL中的容器除了增加移动构造和移动赋值之外，STL容器插入接口函数也增加了右值引用版本。
以vector容器的push_back接口为例：
cpp
#include<vector>
int main()
{
xxhh::string s;
s = xxhh::string("string");
vector<xxhh::string> vs;
vs.push_back("1234");
vs.push_back(xxhh::string("xxhh"));
vs.push_back(std::move(s));
return 0;
}
三、引用折叠
C++中不能直接定义 引用的引用，如 int& &&r = i; 这样写会直接报错，但是可以通过模版或者 typedef 中的类型操作可以构成引用的引用。
typedef类型的
cpp
int main()
{
typedef int& lref;
typedef int&& rref;
int n = 0;
lref& r1 = n;
lref&& r2 = n;
rref& r3 = n;
rref&& r4 = 1;
return 0;
}模版类型操作可以构成引用的引用。
cpp
// 由于引用折叠限定，f1实例化以后总是一个左值引用
template<class T>
void f1(T& x)
{}
// 由于引用折叠限定，f2实例化后可以是左值引用，也可以是右值引用
template<class T>
void f2(T&& x)
{}
int main()
{
int n = 0;
f1<int>(n);
//f1<int>(1);//error
f1<int&>(n);
//f1<int&>(1); //error
f1<int&&>(n);
//f1<int&&>(1);//error
// 折叠 -> 实例化为 void f1(const int& x)
f1<const int&>(n);
f1<const int&>(0);
// 没有折叠 -> 实例化为 void f2(int&& x)
//f2<int>(n); // error
f2<int>(0);
// 折叠 -> 实例化为 void f2(int&x)
f2<int&>(n);
//f2<int&>(0); // error
// 折叠 -> 实例化为 void f2(int&& x)
//f2<int&&>(n); // error
f2<int&&>(0);
return 0;
}能得出以下的结论：
- 由于引用折叠限定，只有一个& （f1）实例化以后总是一个左值引用。
- 由于引用折叠限定，两个&& （f2）实例化后可以是左值，也可以是右值引用。下面我们编写程序，看看什么时候 两个&& 实例化是左值，什么时候是右值。
cpp
template<class T>
void Func(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)
Func(10);
int a;
// a是左值，推导出T为int&，引用折叠，模板实例化为void Function(int& t)
Func(a);
// std::move(a)是右值，推导出T为int，模板实例化为void Function(int&& t)
Func(std::move(a));
const int b = 8;
// a是左值，推导出T为const int&，引用折叠，模板实例化为void Function(const int&t)
// 所以Function内部会编译报错，x不能++
//Func(b);// const 左值
// std::move(b)右值，推导出T为const int，模板实例化为void Function(const int&&t)
// 所以Function内部会编译报错，x不能++
// Func(std::move(b)); // const 右值
return 0;
}四、完美转发
4.1. 万能引用
模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值。比如：
cpp
template<class T>
void PerfectForward(T&& t)
{
//...
}右值引用和万能引用的区别就是，右值引用需要是确定的类型，而万能引用是根据传入实参的类型进行推导，如果传入的实参是一个左值，那么这里的形参t就是左值引用，如果传入的实参是一个右值，那么这里的形参t就是右值引用。
下面重载了四个Func函数，这四个Func函数的参数类型分别是左值引用、const左值引用、右值引用和const右值引用。在主函数中调用PerfectForward函数时分别传入左值、右值、const左值和const右值，在PerfectForward函数中再调用Func函数。如下：
cpp
void Func(int& x)
{
cout << "左值引用" << endl;
}
void Func(const int& x)
{
cout << "const 左值引用" << endl;
}
void Func(int&& x)
{
cout << "右值引用" << endl;
}
void Func(const int&& x)
{
cout << "const 右值引用" << endl;
}
template<class T>
void PerfectForward(T&& t)
{
Func(t);
}
int main()
{
int a = 10;
PerfectForward(a);
PerfectForward(move(a));
const int b = 20;
PerfectForward(b);
PerfectForward(move(b));
return 0;
}由于PerfectForward函数的参数类型是万能引用，因此既可以接收左值也可以接收右值，而我们在PerfectForward函数中调用Func函数，就是希望调用PerfectForward函数时传入左值、右值、const左值、const右值，能够匹配到对应版本的Func函数。
但实际调用PerfectForward函数时传入左值和右值，最终都匹配到了左值引用版本的Func函数，调用PerfectForward函数时传入const左值和const右值，最终都匹配到了const左值引用版本的Func函数 。
根本原因就是，右值被引用后会导致右值被存储到特定位置，这时这个右值可以被取到地址，并且可以被修改 ，所以在PerfectForward函数中调用Func函数时会将t识别成左值 。
也就是说，右值经过一次参数传递后其属性会退化成左值，如果想要在这个过程中保持右值的属性，就需要用到完美转发。
4.2. 完美转发保持值的属性
要想在参数传递过程中保持其原有的属性，需要在传参时调用forward函数。比如：
cpp
void Func(int& x)
{
cout << "左值引用" << endl;
}
void Func(const int& x)
{
cout << "const 左值引用" << endl;
}
void Func(int&& x)
{
cout << "右值引用" << endl;
}
void Func(const int&& x)
{
cout << "const 右值引用" << endl;
}
template<class T>
void PerfectForward(T&& t)
{
Func(std::forward<T>(t));
}
int main()
{
int a = 10;
PerfectForward(a); //左值
PerfectForward(move(a)); //右值
const int b = 20;
PerfectForward(b); //const 左值
PerfectForward(move(b)); //const 右值
return 0;
}经过完美转发后，调用PerfectForward函数时传入的是右值就会匹配到右值引用版本的Func函数，传入的是const右值就会匹配到const右值引用版本的Func函数，这就是完美转发的价值。
完