右值引用，移动拷贝，完美转发forward＜T＞(t)

什么是左值？什么是右值？

左值是一个表示数据的表达式(如变量名或解引用的指针)，我们可以获取它的地址，一般可以对它赋值，左值可以出现赋值符号的左边，右值不能出现在赋值符号左边。定义时const修饰符后的左值，不能给他赋值，但是可以取它的地址。左值引用就是给左值的引用，给左值取别名。

右值也是一个表示数据的表达式，如:字面常量、表达式返回值，函数返回值(这个不能是左值引用返回)等等，右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能取地址。右值引用就是对右值的引用，给右值取别名。

左值引用核心价值是减少拷贝，提高效率
左值引用核心价值是进一步减少拷贝，弥补左值引用没有解决的场景。如:传值返回

int main()
{
	// 以下的ptr、b、c、*p都是左值
	int* ptr = new int(0);
	int b = 1;
	const int c = 2;
	
	// 以下几个都是常见的右值
	10;
	x + y;
	// cout << &10 << endl;不能取地址
	// cout << &(x+y)<< endl;
	
	return 0;
}

左值引用:给左值取别名，右值引用:给右值取别名

int main()
{
	double x = 1.1, y = 2.2;
	// 左值引用:给左值取别名
	int a = 0;
	int& r1 = a;

	// 左值引用能否给右值取别名？
	// const左值引用可以
	const int& r2 = 10;
	const double& r3 = x + y;
	
	// 右值引用:给右值取别名
	int&& r5 = 10;
	double&& r6 = x + y;

	// 右值引用能否给左值取别名？
	// 右值引用可以引用move以后的左值
	int&& r7 = move(a);

	return 0;
}

右值引用可解决的问题1：自定义类型中深拷贝的类，必须传值返回的场景

比如下面代码，fun()函数中返回值str，在出了作用域会被销毁，所以会针对str进行拷贝构造出一个临时变量(第一次深拷贝)，然后再利用临时变量对ret2进行赋值重载(第二次深拷贝)。整个过程发生了两次深拷贝。

bit::string func()
{
	string str("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
	return str;
}

int main()
{
	//string ret1 = func();

	bit::string ret2;
	ret2 = func();

	return 0;
}

解决方法：移动拷贝（浅拷贝） 

利用右值引用进行函数重载，同样的fun()函数中返回值str，在出了作用域会被销毁，所以会针对str进行拷贝构造出一个临时变量(第一次深拷贝)，此时这个临时变量作为ret2的右值，并且为将亡值（内置类型的右值：纯右值，自定义类型的右值：将亡值），此时，会调用重载的函数string& operator=(string&& s)，进行移动拷贝（浅拷贝）构造ret2。

移动构造，直接转移将亡值的资源，this指针直接指向将亡值的地址，同时为了避免析构函数将这片地址（this指针新指向的地址）销毁，将将亡值的地址置空。（swap函数的功劳）

void swap(string& s)
		{
			::swap(_str, s._str);
			::swap(_size, s._size);
			::swap(_capacity, s._capacity);
		}

// 赋值重载
string& operator=(const string& s)
{
	cout << "string& operator=(string s) -- 深拷贝" << endl;
	string tmp(s);
	swap(tmp);

	return *this;
}

string& operator=(string&& s)
	{
	cout << "string& operator=(string && s) -- 移动拷贝" << endl;
	swap(s);

	return *this;
	}


string func()
{
	string str("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
	return str;
}

int main()
{
	//string ret1 = func();

	string ret2;
	ret2 = func(); //此时func()为右值将亡值，会调用重载的函数string& operator=(string&& s)

	return 0;
}

右值引用可解决的问题2：容器的插入接口，如果插入对象是右值，可以利用移动构造转移资源给数据结构中的对象

int main()
{
	list<bit::string> lt;
	bit::string s1("111111111111111111111");
	lt.push_back(s1);  //深拷贝

	cout << endl << endl;
	bit::string s2("111111111111111111111");
	lt.push_back(move(s2)); //移动拷贝

	cout << endl << endl;
	lt.push_back("GG");  //移动拷贝，通过"GG"构造临时对象/匿名对象，底层接收的为右值

	return 0;
}

 

完美转发forward<T>(t)的作用

如下代码,函数Fun(t)，会根据t的类型调用相应的重载函数如void Fun(int& x)，void Fun(const int& x) 等。t的类型有左值也有右值，我们可以预料到程序输出的结果有左值引用也会有右值引用对吧？

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<typename T>
void PerfectForward(T&& t)
{
	// 完美转发，t是左值引用，保持左值属性
	// 完美转发，t是右值引用，保持右值属性
	//Fun(forward<T>(t));
	Fun(t);
}

int main()
{
	PerfectForward(10);           // 右值

	int a;
	PerfectForward(a);            // 左值
	PerfectForward(std::move(a)); // 右值

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

	return 0;
}

但结果却全是左值引用

 这是由于右值引用变量的属性会被编译器识别成左值，否则在移动构造的场景下，无法完成资源转移。

如下图，如果右值s不被识别成左值，就不能调用swap(sting & s)函数，就没办法完成资源转移。右值不能修改，但右值引用可以修改。

 这也就说明了上面的程序为什么输出的全是左值引用。因为Fun(t),在调用的时候，不管t为右值还是左值，他都被识别成了左值。

而完美转发的作用就是，t是左值引用，保持左值属性，t是右值引用，保持右值属性。防止编译器自动识别成左值。

使用完美转发（Fun(forward<T>(t));）后输出结果就符合我们预期了

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<typename T>
void PerfectForward(T&& t)
{
	// 完美转发，t是左值引用，保持左值属性
	// 完美转发，t是右值引用，保持右值属性
	Fun(forward<T>(t));
	//Fun(t);
}

int main()
{
	PerfectForward(10);           // 右值

	int a;
	PerfectForward(a);            // 左值
	PerfectForward(std::move(a)); // 右值

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

	return 0;
}