• C++11新特性（右值引用，万能转发）

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

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

     

    目录

    何为左值，右值 

    左值引用 

    右值引用 

    左值引用的作用和不足 

    右值引用的作用 

    右值引用的无奈

    万能转发

    何为左值，右值 

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

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

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

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

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

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

    1. int a = 10, b = 20, c = 30; 
    2. //a 是左值， 10是字面常量是右值
    3.  
    4. a = b + c;
    5. //a是左值，(b + c)是个表达式，表达式是右值
    6.  
    7. a = min(b, c);
    8. //a 是左值，min(b, c)返回值是个右值

    左值引用 

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

    1. void swap(int& a, int& b)
    2. {
    3.     int c = a;
    4.     a = b;
    5.     b = c;
    6. }
    7.  
    8. int main()
    9. {
    10.     int test1 = 10;
    11.     int test2 = 20;
    12.     swap(test1, test2);
    13.  
    14.     return 0;
    15. }

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

    1. // 以下的b、c、*p都是左值
    2. int* p = new int(0);
    3. int b = 1;
    4. const int c = 2;
    5.  
    6. // 以下几个是对上面左值的左值引用
    7. int*& rp = p;
    8. int& rb = b;
    9. const int& rc = c;

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

    右值引用 

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

    1. int&& test_1 = 10;
    2. //test_1引用字面常量10
    3.  
    4. int x = 10, y =20;
    5. int&& test_2 = x+y;
    6. //test_2引用表达式的值

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

    1. int test1 = 10;
    2.  
    3. int&& b = test1;//不可，因为test1是左值，右值无法引用左值
    4.  
    5. int&& b = std::move(test1) //可以，move()将test1转化成了右值

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

    1. //10是字面常量不可以取地址
    2. //b右值引用10后需要存储，可以取b的地址
    3. int&& b = 10;
    4. cout << (void*)b <
    5.  
    6. //也可以修改b的值，但是这没有什么意义
    7. b = 20;
    8. cout << b <//b的值此时为20

    左值引用的作用和不足 

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

    1. typedef struct test {
    2. 	int a;
    3. 	int b;
    4. 	int c;
    5. }test;
    6.  
    7. void fun(test& tmp1, test& tmp2)
    8. {
    9. 	//do something
    10. 	//...
    11. }
    12.  
    13. int main()
    14. {
    15. 	test t1 = { 10,10,10 };
    16. 	test t2 = { 20,20,20 };
    17. 	fun(t1, t2);
    18.  
    19. 	return 0;
    20. }

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

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

    1. vectorint>> test()
    2. {
    3.       vectorint>> tmp(1000);
    4.       for (int i = 0; i < tmp.size(); i++)
    5.           tmp[i].resize(1000);
    6.       
    7.      //do something...
    8.                
    9.       return tmp;
    10. }
    11.  
    12. int main()
    13. {
    14. 	vectorint>> tt;
    15. 	tt = test();
    16. 	return 0;
    17. }

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

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

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

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

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

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

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

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

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

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

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

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

    右值引用的作用 

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

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

    1. vector<int> test()
    2. {
    3. 	vector<int> tmp(1000);
    4.  
    5. 	//do something...
    6.  
    7. 	return tmp;
    8.     //这里的tmp就是将亡值，因为栈帧销毁后，其生命周期即到头
    9.     //编译器会将这里的tmp其识别为右值
    10. }
    11.  
    12.  
    13. int main()
    14. {	
    15. 	vector<int> tt = test();
    16. 	return 0;
    17. }

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

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

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

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

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

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

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

    1.  
    2. 	class mystring
    3. 	{
    4. 	public:
    5.  
    6. 		mystring(const char* str = "")
    7. 			:_size(strlen(str))
    8. 			, _capacity(_size)
    9. 		{
    10. 			_str = new char[_capacity + 1];
    11. 			strcpy(_str, str);
    12. 		}
    13.  
    14. 		void swap(mystring& s)
    15. 		{
    16. 			std::swap(_str, s._str);
    17. 			std::swap(_size, s._size);
    18. 			std::swap(_capacity, s._capacity);
    19. 		}
    20.  
    21. 		// 拷贝构造
    22. 		mystring(const mystring& s)
    23. 		{
    24. 			mystring tmp(s._str);
    25. 			swap(tmp);
    26.             cout << "string(const string& s) -- 深拷贝" << endl;
    27. 		}
    28.  
    29. 		// 赋值重载
    30. 		mystring& operator=(const mystring& s)
    31. 		{		
    32. 			mystring tmp(s);
    33. 			swap(tmp);
    34.             cout << "string& operator=(string s) -- 深拷贝" << endl;
    35. 			return *this;
    36. 		}
    37.  
    38.  
    39. 		~mystring()
    40. 		{
    41. 			delete[] _str;
    42. 			_str = nullptr;
    43. 		}
    44.  
    45.  
    46. 	private:
    47. 		char* _str = nullptr;
    48. 		size_t _size = 0;
    49. 		size_t _capacity = 0; 
    50. 	};
    51.  
    52. 	mystring test()
    53. 	{
    54. 		mystring str = "this is a test";
    55. 		return str;
    56. 	}

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

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

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

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

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

    1. mystring(mystring&& tmp_obj)
    2. {
    3.  
    4. }
    5.  
    6. mystring& operator=(mystring&& tmp_obj)
    7. {
    8.  
    9. }

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

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

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

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

    1.         //移动拷贝
    2. 		mystring(mystring&& s)
    3. 		{
    4. 			swap(s);
    5. 			cout << "string(const string&& s) -- 移动拷贝" << endl;
    6. 		}
    7.  
    8. 		//移动赋值
    9. 		mystring& operator=(mystring&& s)
    10. 		{
    11. 			if (this != &s)
    12. 			{
    13. 				swap(s);
    14. 			}
    15. 			cout << "string(const string&& s) -- 移动赋值" << endl;
    16. 			return *this;
    17. 		}

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

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

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

    1. class mystring
    2. 	{
    3. 	public:
    4.  
    5. 		mystring(const char* str = "")
    6. 			:_size(strlen(str))
    7. 			, _capacity(_size)
    8. 		{
    9. 			_str = new char[_capacity + 1];
    10. 			strcpy(_str, str);
    11. 		}
    12.  
    13. 		void swap(mystring& s)
    14. 		{
    15. 			std::swap(_str, s._str);
    16. 			std::swap(_size, s._size);
    17. 			std::swap(_capacity, s._capacity);
    18. 		}
    19.  
    20. 		// 拷贝构造
    21. 		mystring(const mystring& s)
    22. 		{
    23. 			cout << "string(const string& s) -- 深拷贝" << endl;
    24.  
    25. 			mystring tmp(s._str);
    26. 			swap(tmp);
    27. 		}
    28.  
    29. 		// 赋值重载
    30. 		mystring& operator=(const mystring& s)
    31. 		{
    32. 			cout << "string& operator=(string s) -- 深拷贝" << endl;
    33. 			mystring tmp(s);
    34. 			swap(tmp);
    35.  
    36. 			return *this;
    37. 		}
    38.  
    39. 		//移动拷贝
    40. 		mystring(mystring&& s)
    41. 		{
    42. 			swap(s);
    43. 			cout << "string(const string&& s) -- 移动拷贝" << endl;
    44. 		}
    45.  
    46. 		//移动赋值
    47. 		mystring& operator=(mystring&& s)
    48. 		{
    49. 			if (this != &s)
    50. 			{
    51. 				swap(s);
    52. 			}
    53. 			cout << "string(const string&& s) -- 移动赋值" << endl;
    54. 			return *this;
    55. 		}
    56.  
    57. 		~mystring()
    58. 		{
    59. 			delete[] _str;
    60. 			_str = nullptr;
    61. 		}
    62.  
    63. 	private:
    64. 		char* _str = nullptr;
    65. 		size_t _size = 0;
    66. 		size_t _capacity = 0; 
    67. 	};

    右值引用搭配移动构造和移动赋值，补齐了左值引用的短板，如此，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的参数是左值引用，另一个就是右值引用，根据传过来的参数选择调用哪个

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

    1.     void fun(int& x) { std::cout << "左值引用" << endl; }
    2.  
    3. 	void fun(int&& x) { std::cout << "右值引用" << endl; }
    4.  
    5.  
    6. 	void fun_call(int&& val)
    7. 	{
    8. 		fun(val);
    9. 	}
    10.  
    11. 	int main()
    12. 	{
    13. 		fun_call(10);
    14. 		return 0;
    15. 	}

    看一下运行结果

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

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

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

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

    1.     void fun(int& x) { std::cout << "左值引用" << endl; }
    2.  
    3. 	void fun(int&& x) { std::cout << "右值引用" << endl; }
    4.  
    5. 	template <class T>
    6. 	void fun_call(T&& val)
    7. 	{
    8. 		fun(val);
    9. 	}

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

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

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

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

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

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

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

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

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

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

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

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

  • 相关阅读:
    索引性能分析
    Java解析Json格式数据
    【论文精读】【DETR】End-to-End Object Detection with Transformers
    前端项目练习（练习-001-纯原生）
    ReentrantLock源码分析
    Java多并发（四）| 锁（Lock接口 & AQS & ReentrantLock）
    VC++将资源文件编译进程序并在运行时释放到文件
    WSL中ubuntu安装mysql数据库
    排序1：快速排序(三种)、归并排序、计数排序
    Dijkstra算法学习总结
  • 原文地址：https://blog.csdn.net/m0_61350245/article/details/133567224