【C语言进阶篇（上）—— 探索我与C的不解之缘（三十）】

一、C++11

这里简单了解一下C++发展好吧：

C++11是C++的第二个大版本，也是自C++98以来最重要的一个版本。

它引入了大量的更改，它曾被人们称为C++0x，因为它被期待在2010年之前发布；但在2011年8月12日才被采纳。

C++03到C++11花了8年时间，这是迄今为止最长的版本间隙；自C++11起C++就有规律的每三年更新一次。

二、列表初始化

C++98中的{}

在之前C++98中是支持对一般数组和结构体使用{}来初始化的

struct A
{
	int _x;
	int _y;
};
int main()
{
	int arr1[] = { 1,2,3,4,5 };//数组使用{}进行初始化
	int arr2[3] = { 0 };
	A a = { 2,2 };//结构体使用{}进行初始化
	return 0;
}

这些在C语言当中都是支持的。

C++11中的{}

C++11中的{}，想统一初始化方式，想要实现一切对象皆可以使用{}初始化；{}初始化也称为列表初始化。

内置类型支持使用{}进行初始化；自定义类型也支持，但是自定义类型支持的本质是类型转化，会产生临时对象，最后被优化成了直接构造

{}在初始化的过程中，也可以省略掉=

class Date
{
public:
	Date(int year = 1, int month, int day)
		:_year(year)
		,_month(month)
		,_day(day)
	{
		cout << "Date(int year = 1,int month = 1,int day = 1" << 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
	//内置类型支持{}初始化
	int a = { 1 };

	//自定义类型也支持{}初始化
	//本质上是{2025,3,31}构造一个Date对象，再进行拷贝构造
	//编译器优化二合一成{2025,3,31}直接构造
	Date d1 = { 2025,3,31 };
	//这里d2引用的就是{2025,3,31}构造的临时对象
	const Date& d2 = { 2025,3,31 };
	
	//C++98中支持单参数时 隐式类型转换，可以不写{}
	Date d3 = { 2025 };
	Date d4 = 2025;

	//可以省略掉=
	int b{ 2 };
	Date d5{ 2025 };
	const Date& d6{ 2006,7,20 };
	//只有使用{}时，才可以省略=
	//Date d7 2025;
	return 0;
}

C++11列表初始化的本意就是想要实现一个统一的初始化方式（无论是内置类型还是自定义类型）

在有些场景还是能够带来很大的便利的，就比如容器push/insert多参数构造对象时，{}就十分方便。

int main()
{
	vector<Date> v;
	Date d = { 2025,3,31 };
	v.push_back(d);
	v.push_back(Date(2025, 1, 1));//匿名对象
	//相比较于有名对象和你们对象，这里使用{}还是很便利的
	v.push_back({ 2025, 1, 1 });
	return 0;
}

C++11中的std::initializer_list

在上面描述中，我们Date类之所以能够使用{2025,3,31}来初始化，那是因为其实现了三个参数的构造函数（都有缺省值）；

那我们vector是否也能使用{}来初始化呢？

显然是不可以的（如果要用N个值去初始化，那就需要有N个参数的构造函数）；

vector<int> v1 = {1 , 2 , 3 , 4 , 5}。（这里如果在自己的编译器上试一下，可能是支持这样的，那是编译器进行了优化处理）

C++11提出了一个initializer_list类，这个类的本质就是开辟一个数组，然后将数据拷贝过来；std::initializer_list内部存在两个指针分别指向数组的开始和结束位置。

initializer_list是支持迭代器遍历的。

容器支持了一个std::initializer_lis的构造函数，支持多个值构成的{x1,x2,x3...}进行初始化。

STL的容器支持任意多个值构成的{x1,x2,x3...}进行初始化都是通过initializer_list进行支持的

什么意思呢？

可以看到，auto arr = {1 , 2 , 3 , 4 , 5};它是类型匹配成initializer_list的，其中存在两个指针(_First和_Last)。

那如何实现STL中容器支持任意多个值{x1 , x2 , x3...}进行初始化呢？

可以看到STL容器在C++11的中支持了initializer_list的构造函数，这样我们就可以使用任意多个值进行初始化了。

int main()
{
	std::initializer_list<int> mylist;
	mylist = { 10, 20, 30 };
	cout << sizeof(mylist) << endl;
	//这里begin和end返回的是initializer_list对象中存在的两个指针_First和_Last
	// 这里连个指针和i的地址接近，这个数组在栈上
	int i = 0;
	cout << mylist.begin() << endl;
	cout << mylist.end() << endl;
	cout << &i << endl;
	//{}列表中可以有任意个值
	//下面第一个是v1的直接构造（编译器将构造和拷贝构造优化成直接构造）
	// 第二个v2是 {1,2,3,4,5}先构造成initializer_list，在调用vector的构造，再进行拷贝构造
	// v2 : 构造临时对象 + 临时对象拷贝 优化成了直接构造
	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++11新增了右值引用这个概念，我们之前学习的引用就叫做左值引用；

这里无论左值引用还是右值引用，都是给对象其别名。

1. 左值和右值

左值是一个表示数据的表达式（例如：变量名/解引用的指针），一般是持久的，存储在内存中，我们可以用获取它的地址；左值可以出现在赋值符号的左边，也可以出现赋值符号的右边。定义时const修饰后的左值，不能给它赋值，但是可以取它的地址。

右值也是一个表达数据的表达式，常见的右值有(字面值常量、表达式求值过程中创建的临时变量、匿名对象等)，右值可以出现在赋值符号的右边，但是不能出现在赋值符号的左边，右值不能取地址。

int main()
{
	//左值可以取地址
	//p,b,c,*p,str,str[0]都是左值
	int* p = new int(0);
	int b = 1;
	const int& c = b;
	*p = 3;
	string str = "12345";
	str[0] = '0';
	cout << &b << endl;
	cout << (void*)&str[0] << endl;
	//&str[0]是char* ,不强转成void* 会被当成字符串输出

	//常见的右值
	double x = 1.1, y = 2.2;
	10;//常量值
	x + y;//表达式计算产生的临时变量
	fmin(x, y);//函数传值返回的返回值
	string("11111");//匿名对象
	return 0;
}

左值的英文简写为lvalue，右值的英文简写为rvalue；（这里可以认为是left value和right value的缩写）

在现代C++中，lvalue被解释为loactor value的缩写，可以理解为在内存中、有明确存储地址，可以取地址的对象；而rvalue被解释为read value，可以理解为那些可以提供数据值，但是不能寻址，（临时变量、字面值常量、存储于寄存器的变量）

也就是说左值和右值的主要区别就在于是否取地址。

2. 左值引用和右值引用

左值引用：Type& r1 = x，左值引用是给左值取别名；

优质引用：Type&& rr1 = y，右值引用就是给右值取别名。

我们之前使用const Type&是可以引用临时变量和匿名对象（右值）的，这里：

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

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

move是库里面的一个函数模版，其作用就是将左值转换成功右值，其本质上是强制类型转换，还设计到一部分引用折叠（这里就简单理解成强制类型转换。

这里有一个需要注意的点：

变量表达式都是左值属性，一个右值被右值引用绑定后，这个右值引用变量表达式的属性是左值；

什么意思呢？就比如：int&& r = 10;（其中10 是常量值是右值，我们定义了右值引用变量r，这个r是一个左值。

从语法层面看，左值引用和右值引用都是取别名，没有开空间；但从汇编角度看，底层都是指针实现的，没有什么区别。

int main()
{
	int* p = new int(0);
	int b = 1;
	const int c = b;
	*p = 10;
	string s("111111");
	s[0] = 'x';
	double x = 1.1, y = 2.2;
	//左值引用
	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是右值引用表达式，rr1属性是左值
	int& r6 = r1;
	// int&& rrx6 = rr1;
	int&& rrx6 = move(rr1);
	return 0;
}

3. 延长生命周期

右值引用也可以用来延长临时对象的生命周期，const左值引用也可以用来延长临时对象的生命周期，但是这些对象不能被修改。

int main()
{
	string s1 = "666666";
	const string& s2 = s1 + s1;//const 左值引用延长临时对象生命周期
	//s2 += "999";//const左值引用不能修改

	string&& s3 = s1 + s1;//右值引用延长临时对象生命周期
	s3 += "999";//可以进行修改

	cout << s1 << endl;
	cout << s2 << endl;
	return 0;
}

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

在C++98中，我们使用const左值引用来作为函数的参数，这样在传参时，左值和右值都可以匹配到const左值引用

C++11有了右值引用以后，现在我们就可以重载左值引用、const 左值引用、右值引用作为参数的func函数；那这样实参是左值就会匹配func(左值引用)、实参是const左值就会匹配func(const 左值引用)、实参是右值就会匹配func(右值引用)。

这里有一个感觉非常奇怪的点就是：右值引用变量在用于表达式时属性是左值（它存在一定有它存在的道理，在后面了解右值引用的使用就会直到这个设计的作用）。

void func(int& x)
{
	cout << "左值引用" << endl;
}
void func(const int& x)
{
	cout << "const 左值引用" << endl;
}
void func(int&& x)
{
	cout << "右值引用" << endl;
}
int main()
{
	int i = 1;
	const int ci = 2;
	func(i); //调用func(int& x)
	func(ci); //调用func(const int& x)
	func(3); //调用func(int&& x)，如果没有就调用func(const int& x)
	func(std::move(i)); //调用func(int&& x)，如果没有就调用func(const int& x)
	int&& x = 1;
	func(x); //右值引用变量的属性是左值，调用func(int& x)
	func(std::move(x)); //x是左值，move(x)是右值，调用func(int&& x)
	return 0;
}

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

说了那么多关于右值引用的语法，那这些有什么用呢？

左值引用的使用

先来看一下左值引用的使用：

之前我们使用左值引用主要就是在函数中左值引用传和左值引用返回值 减少拷贝，同时做到可以修改实参和修改返回值的作用。

我们使用左值引用就已经解决了大多数场景的拷贝效率问题，但是总有一些场景是不能使用传左值引用返回（这里就比如下面的addString函数generate函数），显然是不能进行左值引用返回的；（就只能进行传值返回）

那C++11设计出了右值引用能够使用右值引用返回解决这一问题吗？显然不能。

这里问题的本质是：返回的是一个局部对象，函数结束之后这个对象就析构销毁了，右值引用返回也无法改变它被析构销毁的事实。

// 传值返回需要拷⻉
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;
}
//这里进行传值返回的代价就非常大了
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;
}

移动构造和移动赋值

那右值引用也不能解决传值返回拷贝的问题，C++11也提出了移动构造和移动赋值

移动构造是一种构造函数，类似于拷贝构造函数；

移动构造要求第一个参数是该类类型的引用，于拷贝构造不同的是，移动构造要求这个参数是右值引用（如果却在其他参数，额外参数必须有缺省值）

移动赋值的一个赋值运算符的重载，于拷贝赋值构成函数重载，类似于拷贝赋值；

移动赋值函数要求第一个参数是该类类型的引用，且要求这个参数是右值引用。

这里移动构造和移动赋值对于vector/string这样进行深拷贝的类，或者包含深拷贝的成员变量的类才有意义。

因为移动构造和移动赋值，它们本质上是要掠夺右值引用引用的右值对象的资源，而不是像拷贝构造和拷贝赋值那样去重新开辟资源，从而移动构造和移动赋值效率更高。

移动构造和移动赋值实现的本质就是交换右值对象的资源。

//移动构造
string(string&& s)
{
	swap(s);
}
//移动赋值
string& operator=(string&& s)
{
	swap(s);
	return *this;
}

这里，右值是 临时对象、匿名对象等，右值引用引用的对象，马上就被析构释放了；

移动构造和移动赋值的本质就是要将这些即将释放的资源进行重新利用。

三、移动构造和移动赋值解决传值返回的问题

这部分内容有点多，现在来详细了解

这里为了能够方便观察到拷贝构造和移动构造的次数，就使用自己实现的string：

namespace HL
{
	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;
};
	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;
	}
}

使用的string如上述所示。

只存在拷贝构造，没有移动构造

在没有右值引用和移动构造之前，我们都是使用拷贝构造，我们来看一下它进行传值返回时的拷贝消耗。

现在假设这样的场景（只有拷贝构造）

int main()
{
	HL::string ret = HL::addStrings("11111", "2222");
	cout << ret.c_str() << endl;
	return 0;
}

博主这里使用的是visual Studio 2022，可以看到传值返回时没有调用拷贝构造啊；

这是因为编译器进行了优化将多次拷贝构造进行了优化。

这里如果编译器不进行优化，那就是两次拷贝构造

在vs2019 debug环境下编译器对拷贝的优化，会将两次拷贝构造优化成一次（上图右边所示）

在vs2022和vs2019 release下，编译器优化就会十分恐怖了，会直接将str对象的构造，str拷贝构造的临时对象，临时对象拷贝构造ret对象，三次拷贝构造合三为一，变成直接构造。（如下图所示）

这里对str取地址可以发现和ret地址是一样的：

那也就是说，编译器究极优化以后，str其实就是ret的一个别名(引用)。

这里空口无凭，现在在linux的环境下使用g++ test.cpp -fno-elide-constructors（关闭编译器的优化)，来看一下运行结果：

可以看到确实是两次拷贝构造

存在移动构造

其实编译器的优化已经很好了，如上述，它将多次拷贝构造合成一次；

但是如果只有拷贝构造，那效率就非常依赖编译器了，如果编译器进行了优化，那效率相对还是很高的，但如果编译器没有进行优化那就十分的坑了。

并不是所有的编译器都会进行优化，所有现在来看一下有了移动构造以后，传值问题如何解决

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

这里先来看一下linux不使用编译器优化的运行结果：

先来看一下编译器vs2019 debug下进行的优化，将两次移动构造优化成一次：

最后我们再来看一下编译器的究极优化：

对比上面三种情况：

编译器不进行优化，那也就两次移动构造；我们知道移动构造就是交换一下资源，并没有开辟新的空间和释放旧的空间这些浪费，效率还是很高的；

如果编译器进行优化，那就更好了，效率会更高；（但是这里编译器不进行优化，效率就已经很高了，这样我们就不再依赖于编译器来解决传值返回的拷贝构造问题）。

只存在拷贝赋值，没有移动赋值

有了移动构造，我们降低了上述传值返回进行拷贝构造的消耗，但如果我们传值返回不是调用的拷贝构造，而是拷贝赋值呢？

int main()
{
	HL::string ret("hello");//先创建了一个变量
	//进行一系列操作
	cout << ret.c_str() << endl;
	//然后对其进行赋值
	ret = HL::addStrings("11111", "2222");
	cout << ret.c_str() << endl;
	return 0;
}

现在有上述场景；（现在我们先看只存在拷贝赋值的情况下）

如果编译器不进行优化的情况下，那就是一次拷贝构造，一次拷贝赋值（在linux下测试一下）

在vs2022和vs2019 release下，编译器会对这样的拷贝构造和拷贝赋值进行优化，会将其造优化成一次拷贝赋值。

存在移动赋值

当存在了移动构造和移动赋值以后，这里我们编译器不优化的情况下，这里也就只有一次 移动构造和一次 移动赋值。

**在vs2022和vs2019 release**下，编译器会对这样的移动构造和移动赋值进行优化，会将其造优化成一次移动赋值。

这里总结一下：

在只有拷贝构造和拷贝赋值的情况下，传值返回拷贝的消耗是很大的；编译器虽然做出了一些优化，将多次构造合成一次构造，但这样就会取决于编译器（编译器优化了消耗就低，编译器不优化消耗就很大）。

有了移动构造和移动拷贝之后，虽然传值返回还是会调用多次构造，但是移动构造和移动赋值只是进行资源的交换，效率是很快的，就是编译器不进行优化，两次、三次移动构造效率还是很快；这样我们程序的效率就不会取决于编译器，（编译器优化了更好，不优化效率也不会很低，消耗都很小）。

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

在上述过程中，其实提效不是很明显，因为我们使用的是string；

但是如果我们使用是vector<string>或者list<string>那就可想而知，提效就很明显了。

我们在STL文档中可以看到，C++11之后容器的push和insert系列的接口都增加了右值引用的版本

当是实参是一个左值时，容器就会调用左值版本，调用拷贝构造进行拷贝，将对象拷贝到容器空间中的对象。

如果实参是一个右值，容器就会调用右值版本，调用移动构造，将右值对象的资源转移到容器空间的对象上。

这里还存在一个emplace系列的接口，这个在了解可变参数模板以后再了解这一系列的接口。

这里就不演示list<string>或者vector<string>这些场景了好吧。

四、类型分类

在C++11之后，对类型进行了进一步划分：

右值被划分成了纯右值(pure value，简称prvalue)和将亡值(expiring value，简称xvalue)。

纯右值：字面值常量和求值结果相当于字面值，或者一个不具名的临时对象。（比如10、true、nullptr或者类似于str.subsr(1,3)、str1+str2传值返回函数的调用、或者整型a+b、a++等。

将亡值：指返回右值引用的函数的调用表达式和转化成右值引用的转换函数的调用表达式（比如mave(x)、static_cast<X&&>(x)）

泛左值：（generalized value，简称glvalue），泛左值包含将亡值和左值。

这里简单了解一下，详细可以看一下 值类别和 Value category

五、引用折叠

在C++11中，我们不能直接定义引用的引用，比如int& && r = i这样会报错，但是如果我们通过模版或者typedef类型操作，我们就可以构成引用的引用（这样不会报错）

当我们通过模版或者typedef中的类型操作，构成引用的引用时，C++11给出了关于引用折叠的规则：

右值引用的右值引用折叠成右值引用；

其他的都折叠成了左值引用。

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

当然我们也可以通过类模版，来构成引用折叠

template<class T>
void fun1(T& x)
{}

template<class T>
void fun2(T&& x)
{}
int main()
{
	int n = 0;
	//显示实例化
	fun1<int>(n);
	fun1<int>(0);//err

	fun1<int&>(n);
	fun1<int&>(0);//err

	fun1<int&&>(n);
	fun1<int&&>(0);//err

	fun2<int>(n);//err
	fun2<int>(0);
	
	fun2<int&>(n);
	fun2<int&>(0);//err

	fun2<int&&>(n);//err
	fun2<int&&>(0);
	return 0;
}

根据上图我们会发现，左值引用版本的模板，无论我们给的是左值还是右值，它都会实例化成左值版本；而右值引用版本，我们给的是左值，它就实例化成左值版本；给的是右值就实例化成右值版本。

在有些地方，也将右值版本的模版参数叫做万能引用。

这里我们是显示实例化，现在来看一下编译器根据我们传值来实例化生成的

template<class T>
void func(T&& x)
{
	int a = 0;
	T b = a;
	//x++;
	cout << &a << endl;
	cout << &b << endl;
}
int main()
{
	func(10);
	//右值

	int a;
	func(a);
	//左值

	func(std::move(a));
	//右值
	const int b = 8;
	func(b);
	//const 左值

	func(std::move(b));
	//const 右值

	return 0;
}

六、完美转发

在上述func(T&& x)函数模版中，我们传左值以后实例化的是左值引用的func函数，传右值以后实例化的是右值引用的func函数。

但是在右值的属性时，曾提到右值引用表达式变量的属性是左值，那也就意味着一个右值被右值引用绑定后，右值引用变量表达式的属性是左值，那我们把一个右值引用变量x传给函数func，那么匹配的是左值引用版本的func函数；（这不符合逻辑啊）

C++11对上述情况，通过了完美转发函数：

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

完美转发forword是一个函数模版，它主要还是通过引用折叠的方式实现。

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 func(T&& t)
{
	Fun(t);
	//Fun(std::forward<T>(t));
}
int main()
{
	func(10); // 右值
	int a;
	func(a); // 左值
	func(std::move(a)); // 右值
	const int b = 8;
	func(b); // const 左值
	func(std::move(b)); // const 右值
	return 0;
}

就如上述，不管我们func实例化的是左值引用还是右值引用版本，它再次调用Fun函数，都是调用左值引用版本的

这是因为，不论实例化的是左值引用还是右值引用版本的，我们的变量t它的属性都是左值，那调用的移动是参数是左值的Fun函数。

我们要想通过func调用Fun实现左值引用调用左值引用，右值引用调用右值引用的，那就要通过forword来实现。

到这里本篇内容就结束了，希望对你有所帮助。

制作不易，感谢大佬的支持。

我的博客即将同步至腾讯云开发者社区，邀请大家一同入驻：https://cloud.tencent.com/developer/support-plan?invite_code=2oul0hvapjsws

作者：迟来的grown