C++11详解(二) -- 引用折叠和完美转发

文章目录

[2. 右值引用和移动语义](#2. 右值引用和移动语义)
- [2.6 类型分类（实践中没什么用）](#2.6 类型分类（实践中没什么用）)
- [2.7 引用折叠](#2.7 引用折叠)
- [2.8 完美转发](#2.8 完美转发)
- [2.9 引用折叠和完美转发的实例](#2.9 引用折叠和完美转发的实例)

2. 右值引用和移动语义

2.6 类型分类（实践中没什么用）

C++11以后，进一步对类型进行了划分，右值被划分纯右值 (pure value，简称prvalue)和将亡值
纯右值 是指那些字面值常量 或(表达式的返回值 )求值结果相当于字面值或是一个不具名的临时对象 。如： 42、true、nullptr 或者类似 str.substr(1, 2)、str1 + str2 传值返回函数调用，或者a++，a+b 等。纯右值和将亡值C++11中提出的，C++11中的纯右值概念划分等价于C++98中的右值
将亡值 是指返回右值引用的函数的调用表达式 和转换为右值引用的转换函数的调用表达(可以是强制类型转换)，如move(x)、static_cast<X&&>(x) -> (X&&)x(其实是强制类型转化)，左值被强转，左值被move之后变为将亡值
泛左值 (generalized value，简称glvalue)，泛左值包含将亡值 和左值
有名字就是泛左值 ，有名字且未被移动的就是左值，有名字且被移动的就是将亡值 ，没有名字且不可以被移动的就是纯右值 ，纯右值在实践中可以被移动，比如匿名对象的资源在函数内部被引用属性变为左值，可以转移资源，实践中将亡值和纯右值可以被移动

2.7 引用折叠

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

引用折叠的规则：右值引用的右值引用折叠成右值引用，所有其他组合均折叠成左值引用。

像f2函数一样，传左值是左值引用,传右值是右值引用，T&& x参数看起来是右值引用参数，但是由于引用折叠的规则，他传递左值时就是左值引用，传递右值时就是右值引用，这就是万能引用

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

搞这么麻烦的东西，其实是为了实现这个万能模版

引用折叠

cpp 复制代码

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

显示实例化

cpp 复制代码

// 由于引用折叠限定，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)
	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;
}

万能模版

cpp 复制代码

// 万能引用,传左值是左值,传右值是右值
// 实践中就可以不用写两个模版了
template<class T>
void Function(T&& t)
{
	int a = 0;
	T x = a;
	//x++;
	cout << &a << endl;
	cout << &x << endl << endl;
}

const int&& ,虽然在函数内有左值属性，可以修改了，但是在此基础上加了const，就不能修改了，相当于const 左值引用

推导实例化

cpp 复制代码

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

2.8 完美转发

如果t是左值引用的话，里面的Fun(t)调用的是左值引用，如果t是右值引用，调用的还是左值引用，因为在函数体内右值具有了左值的属性

cpp 复制代码

template<class T>
void Function(T&& t)
{
	Fun(t);
	//Fun(forward<T>(t));
}

完美转发可以解决上述的问题

Fun(forward< T >(t)) 中如果，T是int&,会保证t还是是左值属性，如果T是int，会保证t还是右值属性 ，不会让t的属性退化，正常的不用完美转发，右值引用之后右值会退化成左值属性
底层（强转和特化处理的）是这样处理的：如果是左值属性，就不动，如果是右值属性，就把左值属性强转为右值属性

下面是push_back函数右两个版本的，左值走拷贝构造，右值走移动构造

2.9 引用折叠和完美转发的实例

引用折叠和完美转发的实际作用：

避免了代码的冗余，不用写一份右值引用和一份左值引用的了，直接写成函数模版就非常好

X&& data = T(),因为类模板实例化出了T为string,如果T是string的左值引用给不过去，因为是左值是string&,T是右值的话，可以给过去，右值是string，所以要写成 X&& data,还要写一份强制生成左值和右值的构造