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

2. 右值引用和移动语义

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

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

2.7 引用折叠

1. C++中不能直接定义引用的引用如 int& && r = i; 这样写会直接报错，通过模板或 typedef中的类型操作可以构成引用的引用。
2. 引用折叠的规则：右值引用的右值引用折叠成右值引用，所有其他组合均折叠成左值引用。
3. 像f2函数一样，传左值是左值引用,传右值是右值引用，T&& x参数看起来是右值引用参数，但是由于引用折叠的规则，他传递左值时就是左值引用，传递右值时就是右值引用，这就是万能引用
4. Function(T&& t)函数模板程序中，假设实参是int右值，模板参数T的推导int，实参是int左值，模板参数T的推导int&，再结合引用折叠规则，就实现了实参是左值，实例化出左值引用版本形参的Function，实参是右值，实例化出右值引用版本形参的Function
5. 搞这么麻烦的东西，其实是为了实现这个万能模版

引用折叠

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

显示实例化

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

万能模版

// 万能引用,传左值是左值,传右值是右值
// 实践中就可以不用写两个模版了
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 左值引用

推导实例化

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是右值引用，调用的还是左值引用，因为在函数体内右值具有了左值的属性

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,还要写一份强制生成左值和右值的构造