这篇文章是C++的重中之重，通过这篇文章你能体会到C/C++大佬们对性能的极致追求，你能感受到独属C/C++人的浪漫，对高消耗的零容忍，对高性能的不倦探索。右值引用是由Scott Meyers在他的著名书籍《Effective C++》中提出的，因为其重要性，很快就被C++委员会加入到C++11之中，接下来一起探讨右值引用的神奇之处

在阅读此篇文章前，请务必确保你已经知道引用，构造函数，拷贝构造等概念

 

目录

何为左值，右值 

左值引用 

右值引用 

左值引用的作用和不足 

右值引用的作用 

右值引用的无奈

万能转发

---

何为左值，右值 

引用我们都知道，给变量取别名，能够像指针一样使用变量，但要搞明白左值引用和右值引用，我们得先区分一下何为左值，何为右值。有些同学认为在赋值符号 "=" 右边的就是右值，在其左边的就是左值，这种说法是不准确的，如下例

int a = 10;
int b = 20;
a = b;
//你能说此时的b是一个右值吗？

还有的同学说，能够被修改值的就是左值，不能被修改值的就是右值，这种说法也是不准确的，看下列代码 

const int a = 10;
int b = 20;
a = b;
//此时的a无法被改值，但是你能说a是右值吗？

基于左值右值的一些特性，笔者对左值右值换个容易理解的定义：对于某个变量我们可以获取它的地址+可以对它赋值（被const修饰的无法赋值），那我们可以称其为左值。注意：左值可以出现在 "=" 的右边，但是右值不能出现在 "=" 左边，右值不能被赋值和取地址

常见的右值：字面常量、表达式返回值，函数返回值，将亡值

int a = 10, b = 20, c = 30; 
//a 是左值， 10是字面常量是右值

a = b + c;
//a是左值，(b + c)是个表达式，表达式是右值

a = min(b, c);
//a 是左值，min(b, c)返回值是个右值

左值引用 

我们平时使用的引用基本都是左值引用，在没了解过右值引用概念之前，很少有人闲着去给引用右值，我们平时使用左值引用，一般都是函数传参使用，代替传指针

void swap(int& a, int& b)
{
    int c = a;
    a = b;
    b = c;
}

int main()
{
    int test1 = 10;
    int test2 = 20;
    swap(test1, test2);

    return 0;
}

 如此以来，test1和test2不用传地址过去就能够交换值，这是左值引用常见的用法

// 以下的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;

如果对左值仍有不了解的地方， 请翻阅笔者前面写的关于左值的文章

右值引用 

左值引用相当于给左值取别名，那么右值引用就是给右值取别名了，这么说也是可以，C++中的右值引用是使用&&来标识，如下列

int&& test_1 = 10;
//test_1引用字面常量10

int x = 10, y =20;
int&& test_2 = x+y;
//test_2引用表达式的值

右值引用不可以引用左值，如果要引用左值，必须使用move()将左值转换成右值  

int test1 = 10;

int&& b = test1;//不可，因为test1是左值，右值无法引用左值

int&& b = std::move(test1) //可以，move()将test1转化成了右值

右值是不能取地址的，但是给右值取别名后，会导致右值被存储到特定位置，且可以取到该位置的地址。虽不能取字面量10的地址，但是b引用后，可以取b的地址，也可以修改b。若不想b被修改，可以用const int&& b 去引用，修改b了解一下即可，右值引用的使用场景并不在于此，不重要 

//10是字面常量不可以取地址
//b右值引用10后需要存储，可以取b的地址
int&& b = 10;
cout << (void*)b <<endl;

//也可以修改b的值，但是这没有什么意义
b = 20;
cout << b <<endl; //b的值此时为20

左值引用的作用和不足 

先来看看左值引用的作用，一般我们使用左值引用最多的场景就是函数传参和传返回值，类似于传指针一样，但是用起来比指针舒服多了，指针还要取地址，还要解引用

typedef struct test {
	int a;
	int b;
	int c;
}test;

void fun(test& tmp1, test& tmp2)
{
	//do something
	//...
}

int main()
{
	test t1 = { 10,10,10 };
	test t2 = { 20,20,20 };
	fun(t1, t2);

	return 0;
}

上述代码中，我们通过传左值引用，可以很好的减少传值拷贝带来的消耗，struct 占用空间越大，传左值引用节省的空间和时间就越明显。指针能做到，但是指针没有引用简洁方便

但是传左值引用也有它解决不了的场景，我们看下述代码示例 

vector<vector<int>> test()
{
      vector<vector<int>> tmp(1000);
      for (int i = 0; i < tmp.size(); i++)
          tmp[i].resize(1000);
      
     //do something...
               
      return tmp;
}

int main()
{
	vector<vector<int>> tt;
	tt = test();
	return 0;
}

遇到这样的场景怎么办，tmp是一个非常大的二级vector， 直接返回tmp，这个拷贝消耗太大了，我们来仔细分析一下，如下图

可见，简简单单的一个返回，会带来一次拷贝构造，一次赋值重载，拷贝构造和赋值重载对空间和性能消耗差不多，都是非常恐怖的，何况这是一个二级vector，涉及到深拷贝。

这里我们换一种写法，编译器会进行一次优化，如下图

说了那么多，好像没提到使用左值引用，因为这里不可以使用左值引用

我们来分析如果以传引用的形式返回会发生什么

这样看着传左值引用返回，确实可以节省一半的开销， 但你不要忘了，tmp出了栈之后会立马调用析构给自身的资源给释放了，也就是说临时空间里引用的tmp是一个已经被销毁释放了资源的二级vector，再去赋值给tt，程序会崩溃的

这种写法，和上述的结果一样，tmp是在test这个栈帧里创建的，返回值返回后，该栈帧及tmp对象被销毁，tt在引用一块已经销毁的空间，这是绝不允许的

这种场景有一种解决方法就是使用输出型参数，C语言经常应用这种写法，但是这种方法用起来比较别扭， 不利于对代码的阅读

所谓输出型参数就是说，在test函数里创建的tmp传引用返回后不是会被销毁嘛，那我就提前在main函数里把tmp给创建好，然后传左值引用把tmp传过去，这样连返回值都不需要，就像C语言要改值传指针一样

这种写法别扭，函数参数看起来也很长，如果多几个参数，用起来就让人头大 

上面讨论的场景就是左值引用没法很好解决的场景

而右值引用的出现，就是在填补这一块的不足

右值引用的作用 

还记得我们前面提到常见的右值有字面常量，表达式，函数返回值，将亡值

前面三个都好理解，可是将亡值是什么意思，顾名思义，就是快死去了，这里的快死去是指该值的生命周期要到头了，举个例子

vector<int> test()
{
	vector<int> tmp(1000);

	//do something...

	return tmp;
    //这里的tmp就是将亡值，因为栈帧销毁后，其生命周期即到头
    //编译器会将这里的tmp其识别为右值
}


int main()
{	
	vector<int> tt = test();
	return 0;
}

tmp是将亡值，属于右值，可这有何用处呢？

虽然你是将亡值， 可你tmp身上存着很多要返回的数据（也就是还背着很多的资源），返回的过程就是tmp把自身的资源拷贝给临时变量，然后自身资源释放，临时变量也是如此，临时变量要把资源拷贝给tt，然后自身资源释放

这里的tmp和临时变量都是将亡值，拷贝后就死掉了，拷贝资源的过程是相当消耗计算机时间和空间的，这个过程也太浪费了

既然将亡值都快死了，死了自身资源也是释放，干脆不要进行资源拷贝了，直接把你身上的资源转移给我，tmp内部指向资源的指针交换给临时变量，临时变量也是将亡值，也不要拷贝了，直接把指向资源的指针交换给tt，交换资源的消耗相比拷贝资源不值一提

可见将亡值能玩得一好手偷天换日，乾坤大挪移

不能光说，得实现出来呀，实现这种玩法的关键就是移动构造，移动赋值

我们逐个分析，为了更好的分析这个过程，笔者把曾经实现的string给拿出来，并进行大量删减，把用不到内容都给删掉，先熟悉一下代码，后续分析过程就使用这些代码

	class mystring
	{
	public:

		mystring(const char* str = "")
			:_size(strlen(str))
			, _capacity(_size)
		{
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}

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

		// 拷贝构造
		mystring(const mystring& s)
		{
			mystring tmp(s._str);
			swap(tmp);
            cout << "string(const string& s) -- 深拷贝" << endl;
		}

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


		~mystring()
		{
			delete[] _str;
			_str = nullptr;
		}


	private:
		char* _str = nullptr;
		size_t _size = 0;
		size_t _capacity = 0; 
	};

	mystring test()
	{
		mystring str = "this is a test";
		return str;
	}

为了测试结果更加清晰，笔者把调用拷贝构造和调用赋值重载的情况都给打印出来，这样运行之后，我们就知道总共进行了几次拷贝，先演示一下没有移动构造和移动赋值的情况

调用了两次拷贝构造，一次赋值重载，为什么是两次拷贝构造呢？因为我们赋值重载的底层实现就是调用拷贝构造，所以就多打印了一次拷贝构造

ps:如果你使用的是vs2022，编译器会对返回值进行优化，看不到上述的情况，这时可以给返回值放到std::move()里面即可取消优化

分析可知，上述返回值是将亡值，临时变量也是将亡值，遇到这种将亡值直接转走资源 

这两次乾坤大挪移的关键就是移动构造和移动赋值，移动构造及移动赋值的定义框架如下 

mystring(mystring&& tmp_obj)
{

}

mystring& operator=(mystring&& tmp_obj)
{

}

移动构造和移动赋值，本质上还是干着拷贝和赋值的工作，只不过以往拷贝构造和赋值重载接收到的对象是const 左值引用，因为不确定这个左值引用接下来是否还继续使用，我们不敢动这个左值引用，只能老老实实一步一步拷贝

但是移动构造和移动赋值接收到的参数是右值引用，右值引用意味着传过来的是一些将亡的，即将要销毁的对象，放心大胆的把它的资源给转走

库中的各个容器也都实现移动构造和移动赋值，以vector为例

库中的实现要考虑非常多的情况，我们仅仅是学习这种思想，怎么简单怎么来，我们自己动手实现简易版的移动构造和移动赋值，实现如下  

        //移动拷贝
		mystring(mystring&& s)
		{
			swap(s);
			cout << "string(const string&& s) -- 移动拷贝" << endl;
		}

		//移动赋值
		mystring& operator=(mystring&& s)
		{
			if (this != &s)
			{
				swap(s);
			}
			cout << "string(const string&& s) -- 移动赋值" << endl;
			return *this;
		}

实现起来是不是非常简单，其实本质就是交换资源，直接swap一下指向资源的指针即可

下图是给mystring类增加移动构造，移动赋值后调用test函数的运行结果 

叫移动构造和移动拷贝都是可以的，如下是添加移动构造和移动赋值后的mystring类  

class mystring
	{
	public:

		mystring(const char* str = "")
			:_size(strlen(str))
			, _capacity(_size)
		{
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}

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

		// 拷贝构造
		mystring(const mystring& s)
		{
			cout << "string(const string& s) -- 深拷贝" << endl;

			mystring tmp(s._str);
			swap(tmp);
		}

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

			return *this;
		}

		//移动拷贝
		mystring(mystring&& s)
		{
			swap(s);
			cout << "string(const string&& s) -- 移动拷贝" << endl;
		}

		//移动赋值
		mystring& operator=(mystring&& s)
		{
			if (this != &s)
			{
				swap(s);
			}
			cout << "string(const string&& s) -- 移动赋值" << endl;
			return *this;
		}

		~mystring()
		{
			delete[] _str;
			_str = nullptr;
		}

	private:
		char* _str = nullptr;
		size_t _size = 0;
		size_t _capacity = 0; 
	};

右值引用搭配移动构造和移动赋值，补齐了左值引用的短板，如此，C++提升程序效率的能力更近一步，不过右值引用可不仅是用于返回值的处理，接下来看看右值引用的另一个场景

下图代码，我们使用了list，元素类型为我们写的mystring类，并且屏蔽掉了我们写好的移动构造和移动赋值，然后push一个mystring匿名对象

由运行结果可知，mystring这个匿名对象如果作为参数传递给list，在没有移动构造的情况下，就是使用拷贝构造把这个匿名对象拷贝给list中的元素值，然后自身销毁，有了右值的概念，我们一眼就能看出这个匿名对象是一个将亡值，根本没有必要去拷贝，直接把资源转移给list中的元素值，下图是加上移动构造和移动赋值后的调用情况

可以看出，编译器会自动识别出这个匿名类对象是一个将亡值，然后会调用我们写好的移动构造，这可比之前调用拷贝构造的效率高多了

右值引用的无奈

右值引用也有一些无奈的场景

1.待拷贝对象中的成员变量只有浅拷贝

右值引用大显神威的场景就是有深拷贝，需要耗费大量资源去完成拷贝的地方

但是有些场景类本身所占用的内存容量不大，比如一个类中的成员变量是一个数组，这个时候右值引用并不会发挥更高效能，也是只能老老实实去拷贝一个数组，所以想提高程序的效率，成员变量占用内存稍大一点可以考虑换成堆区，而非栈区

2.待拷贝对象不明确是否为一个右值，编译器不敢将其识别为右值，如下图场景

这种场景下，即使test_2我们后续不使用了，但是它并没有明确指定为右值，至少它现在还是一个左值，编译器又不知道你后续是否还使用test_2，所以编译器不敢去调用移动赋值，把test_2的资源给换走，只能老老实实走赋值重载

当然这种场景也是可以解决的，如果你明确test_2不再使用，那么你可以使用std::move()，将test_2给转换为右值，这样编译器就敢去交换了，但是切记，不要乱用，如果你后续某个东西用到了test_2，后悔都来不及，如下图 

使用std::move()将test_2明确转换为右值，编译器就会去调用移动赋值

万能转发

在前面讲述过程中，我们提到了这么一个场景，就是用库中的list去push一个我们实现的mystring匿名类，然后程序就调用了我们的移动构造，这就意味着我们要重载一次push函数，一个push的参数是左值引用，另一个就是右值引用，根据传过来的参数选择调用哪个

现在请大家看这么一个场景   

    void fun(int& x) { std::cout << "左值引用" << endl; }

	void fun(int&& x) { std::cout << "右值引用" << endl; }


	void fun_call(int&& val)
	{
		fun(val);
	}

	int main()
	{
		fun_call(10);
		return 0;
	}

看一下运行结果

怎么回事，怎么调用了左值引用，我们传的参数可是字面常量10呀，仔细分析就可以发现，确实我们传的参数就是字面常量10，也确实被右值引用val给接收了，但不要忘了，右值引用变量val本身是一个左值，它只是接收并绑定一个右值，你把val作为参数是在传左值

这就引出了一个问题，右值身份的中转失效，上列的代码中，我们通过中转函数fun_call中转调用fun，而这一次中转，传过去的右值会被右值引用变量接收，但是右值引用变量本身是一个左值，这就导致右值身份在中转过程中失效

还有一个问题呀，你这个中转函数fun_call()的参数是int&& val，val只能接收右值，不能接收左值，，改成int& val倒是可以接收右值和左值，但是右值会当成左值被中转，就丧失了传右值的作用，有没有办法能够让这个中转函数fun_call()既能接收右值，又能接收左值呢？

有的，C++给我们提供了模板&&引用，看下述代码

    void fun(int& x) { std::cout << "左值引用" << endl; }

	void fun(int&& x) { std::cout << "右值引用" << endl; }

	template <class T>
	void fun_call(T&& val)
	{
		fun(val);
	}

如此以来，val既能接收右值又能接收左值了

这好像没啥变化呀，不就是把前面int给改成了模板类型T了吗？本质不还是右值引用吗？

这里的 T&&val 可不是T类型的右值引用，而是C++模板提供的不确定类型引用

也就是说这个东西不仅可以接收右值引用，还可以接受左值引用，除此之外，还可以接收const左值引用和const右值引用，我们也称其为引用折叠

现在我们解决了fun_call()这个中转函数只能接收固定类型参数的问题

现在我们该解决最初提到的右值中转失效的问题

C++给出的解决方法就是完美转发：std::forward

完美转发在传参的过程中保留对象原生类型属性，也就是说val如果是右值引用，那么使用完美转发后，把val作为参数，就会将其视为右值

val如果是左值引用，那么使用完美转发后，把val作为参数，就会将其视为左值

用咱们之前的程序测试一下结果如何

使用模板和完美转发后，确实解决了我们前面提到的这些问题，这些在程序编写中还是很常用的，希望大家能够掌握

我们前面模拟实现的list，其就涉及到了中转调用的问题，当你发现中转调用，右值引用失效时，那么你可以尝试使用完美转发来解决