【C++】右值引用和移动语义（详细解析）

最新推荐文章于 2024-04-29 11:56:38 发布
最新推荐文章于 2024-04-29 11:56:38 发布
阅读量904 收藏 14
点赞数 12
分类专栏： C++基础 文章标签： c++ 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_63449996/article/details/130927370
版权

文章目录

1.左值引用和右值引用

传统的C++语法中就有引用的语法，而C++11中新增了右值引用语法特性，所以从现在开始我们之前学习的引用就叫做左值引用。无论左值引用还是右值引用，都是给对象取别名。

左值引用

  1. 左值是一个表示数据的表达式（如变量名或解引用的指针）；
  2. 我们可以获取它的地址；
  3. 我们可以对它赋值；
  4. 左值可以出现在赋值符号的左边，也可以出现在赋值符号的右边；
  5. 定义const修饰符后的左值，不能给它赋值，但是可以取它的地址；
  6. 左值引用就是给左值引用，即给左值取别名。

使用方法：

#include<iostream>
#include<vector>
using namespace std;

int main()
{
	//以下的p,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;
	int& pvalue = *p;

	return 0;
}

右值引用

  1. 右值也是一个表示数据的表达式（如字面常量，表达式返回值，函数返回值等等）；
  2. 右值引用可以出现在赋值符号的右边，但是不能出现在赋值符号的左边。
  3. 右值不能取地址。
  4. 右值就是对右值的引用，给右值取别名。
int main()
{
	double x = 1.1, y = 2.2;
	// 以下几个都是常见的右值
	10;
	x + y;
	fmin(x, y);
	// 以下几个都是对右值的右值引用
	int&& rr1 = 10;
	double&& rr2 = x + y;
	double&& rr3 = fmin(x, y);
	// 这里编译会报错：error C2106: “=”: 左操作数必须为左值
	10 = 1;
	x + y = 1;
	fmin(x, y) = 1;
	
	return 0;
}

一定要注意：右值是不能取地址的，但是给右值取别名后，会导致右值被存储到特定位置，且可以取到该位置的地址，也就是说，我们本来不能取字面量10的地址，但是rr1引用后，导致我们可以对rr1取地址了，也可以修改rr1，这个时候rr1就变成左值了。如果不想rr1被修改，可以用const int&& rr1去引用，为什么用const修饰之后就可以了呢？因为——x+y这个表达式的返回值是临时变量，临时变量具有常性，所以用const修饰之后就不会报错了。

int main()
{
	double x = 1.1, y = 2.2;
	x + y;
	10;
	int&& rr1 = 10;
	const double&& rr2 = x + y;

	rr1 = 20;
	//rr2 = 5.5; //报错

	return 0;
}

2.左值引用和右值引用的比较

注意两点：

  • 能不能取地址是区分左值引用和右值引用的主要区别。
  • 不能认为有分配空间的就是左值引用，没有被分配空间的就是右值引用。因为在上述的例子中，x+y表达式是右值，但是实际上它是占用空间的，表达式的返回值存储在临时变量中。

左值引用总结

  • 左值引用只能引用左值，不能引用右值
  • 但是const修饰的左值引用可以给右值取别名，也可以引用左值
int main()
{
	//左值
	int a = 10;
	//左值引用可以引用左值
	int& ra1 = a;
	//左值引用不能引用右值
	int& ra2 = 10;//编译失败，因为10常量是右值

	//const修饰的左值引用可以引用左值，也可以引用右值
	const int& ra3 = a;
	const int& ra4 = 10;
	
	return 0;
}

右值引用总结

  • 右值引用只能给右值取别名，不能引用左值
  • 但是右值引用可以给move后的左值取别名
int main()
{
	int a = 0;
	int b = 1;
	int* p = &a;

	a + b;

	//右值引用可以给右值取别名
	int&& raf1 = 10;
	int&& raf2 = a + b;

	//右值引用可以给move后的左值取别名
	int&& raf3 = a;//报错：无法将右值引用绑定到左值
	int&& raf3 = std::move(a);
}

3.右值引用的使用场景和意义

出现右值的原因之一：可以把左值和右值区分开。
我们来看以下代码，函数名都为func，但是参数不同，一个是左值引用，一个是右值引用，我们来看看能否运行成功，将左值和右值区分开。

#include<iostream>
#include<vector>
using namespace std;
void func(int& a)
{
	cout << "void func(int& a)" << endl;
}
void func(int&& a)
{
	cout << "void func(int&& a)" << endl;
}
int main()
{
	int a = 0;
	int b = 1;
	func(a);//这里a是左值
	func(a + b);//这里a+b是右值

	return 0;
}

运行结果：OK，编译通过，运行正确。所以虽然函数名相同，但是由于参数不同，调用的函数也不同。
最重要的是我们把左值和右值区分出来了。
在这里插入图片描述

前面我们可以看到左值引用既可以引用左值和又可以引用右值，那为什么C++11还要提出右值引用呢？是不是化蛇添足呢？下面我们来看看左值引用的短板，右值引用是如何补齐这个短板的！

左值引用存在的短板：

之前我们学习过 左值引用可以直接减少拷贝。

  1. 左值引用传参；
  2. 传引用返回。

但是如果函数内是局部对象，局部对象出了函数作用域那块空间就销毁了，这种情况下是不能用引用返回的。 对引用还不太理解的宝子可以先看这篇文章：【C++】引用&详细解析

右值引用如何解决左值引用存在的短板?

对于右值，有些书上又将其分为纯右值和将亡值。纯右值一般是内置类型，将亡值一般是自定义类型。如果右值将亡了，还对它进行深拷贝代价是有点高的，所以对于右值（将亡值），我们采用的是资源转移，即不重新开辟空间。上图！
在这里插入图片描述
接下来，我们来看几个例子，这样能更加理解左值引用和右值引用。

知识点1

例一：这里采用的是自定义string类。便于调试观察每个步骤调用的是什么函数。

在这里插入图片描述

知识点2

例二：下面是一个可以将整型转换成字符串的函数——注意是传值返回。同样用的是自定义的string类，这样调试时便于观察每个步骤调用的是哪个函数。

namespace nan
{
	nan::string to_string(int value)
	{
		bool flag = true;
		if (value < 0)
		{
			flag = false;
			value = 0 - value;
		}
		nan::string str;
		while (value > 0)
		{
			int x = value % 10;
			value /= 10;
			str += ('0' + x);
		}
		if (flag == false)
		{
			str += '-';
		}
		std::reverse(str.begin(), str.end());
		return str;
	}
}
int main()
{
	// 在nan::string to_string(int value)函数中可以看到，这里
	// 只能使用传值返回，传值返回会导致至少1次拷贝构造(如果是一些旧一点的编译器可能是两次拷
	//贝构造)。
	nan::string ret1 = nan::to_string(1234);
	return 0;
}

在这里插入图片描述

在这里插入图片描述
解释例2：返回时，由于编译器做了优化，将返回值（左值）通过某种方式转变成了右值（将亡值），所以直接采用了移动构造，即先调用了移动构造函数，然后才调用了析构函数。、

知识点3

move是库里面的函数，如果右值想引用左值，用上move函数即可。但是move函数不能随便乱用哦，大家看下面这个代码，先构造了s1，然后用s1拷贝构造s2，s1是左值，第3句代码想将s1通过move函数转换成右值，进行移动构造。
但是从运行结果我们发现，s1的家竟被s3偷了，所以一定要辨别使用场景，不能乱用move函数。

在这里插入图片描述
注意：move函数不是将s1转换成右值，而是move函数的返回值是右值。
这样写就不会被偷家了：
在这里插入图片描述

知识点4

C++11以后，STL所有的容器都增加了移动构造：
在这里插入图片描述
并且STL所有的容器的插入数据接口都增加了右值引用版本。
在这里插入图片描述
那么有什么意义呢？
在这里插入图片描述
第一种尾插方式采用的是拷贝构造函数——深拷贝，所以会再拷贝出一份s1，然后插入链表中，通过下面的调试窗口，可以看出原来的字符串s1还存在。
在这里插入图片描述
在这里插入图片描述
第二种尾插方式采用的是移动构造——浅拷贝，直接转移资源，将前面深拷贝构造出来的s1直接拿来尾插，不需要再深拷贝构造一个s1，又大大提高了效率。但是，通过调试窗口发现，s1被偷家了，悬空了！所以要注意一下这点。
在这里插入图片描述

总结

问题：匿名对象属于左值还是右值？——答案：匿名对象是右值。

在这里插入图片描述
总结：

  1. C++98，只有拷贝构造；C++11之后，既有拷贝构造，也有移动构造；
  2. 左值引用减少拷贝，提高效率，右值引用也是减少拷贝，提高效率，但是它们的角度不同，左值引用是直接减少拷贝，右值引用是间接减少拷贝，编译器先识别数据是左值还是右值，如果是右值，则不再深拷贝，直接移动拷贝（直接移动资源），提高效率。

4.完美转发

万能引用

模板中的&& , 不代表右值引用，而是万能引用，其既能接收左值又能接收右值。

栗子如下：

template<class T>
void PerfectForward(T&& t)
{
	//...
}

然后我们现在通过下列代码，观察一个现象：

下面重载了四个Func函数，这四个Func函数的参数类型分别是左值引用、const左值引用、右值引用和const右值引用。在主函数中调用PerfectForward函数时分别传入左值、右值、const左值和const右值，在PerfectForward函数中再调用Func函数。如下：

#include<iostream>
using namespace std;

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

运行结果：
在这里插入图片描述
由于PerfectForward函数的参数类型是万能引用，因此既可以接收左值也可以接收右值，而我们在PerfectForward函数中调用Func函数，就是希望调用PerfectForward函数时传入左值、右值、const左值、const右值，能够匹配到对应版本的Func函数。但实际调用PerfectForward函数时传入左值和右值，最终都匹配到了左值引用版本的Func函数，调用PerfectForward函数时传入const左值和const右值，最终都匹配到了const左值引用版本的Func函数。

在这里插入图片描述

造成这种结果的原因：

根本原因就是：右值被引用后会导致右值被存储到特定位置，这时这个右值可以被取到地址，并且可以被修改，所以在PerfectForward函数中调用Func函数时会将t识别成左值。因为右值默认具有常性，右值引用后属性是左值，这样才能实现资源转移。
在这里插入图片描述

也就是说，右值经过一次参数传递后其属性会退化成左值，如果想要在这个过程中保持右值的属性，就需要用到完美转发。

见识完美转发的使用

保持原有属性的关键：要想在参数传递过程中保持其原有的属性，需要在传参时调用std::forward函数。

#include<iostream>
using namespace std;

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)
{
	// std::forward<T>(t)在传参的过程中保持了t的原生类型属性。
	Fun(forward<T>(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;
}

运行结果：
在这里插入图片描述

完美转发的使用场景

下面模拟实现了一个简化版的list类，类当中分别提供了左值引用版本和右值引用版本的push_back和insert函数。

namespace zxn
{
	template<class T>
	struct ListNode
	{
		T _data;
		ListNode* _next = nullptr;
		ListNode* _prev = nullptr;
	};
	template<class T>
	class list
	{
		typedef ListNode<T> node;
	public:
		//构造函数
		list()
		{
			_head = new node;
			_head->_next = _head;
			_head->_prev = _head;
		}
		//左值引用版本的push_back
		void push_back(const T& x)
		{
			insert(_head, x);
		}
		//右值引用版本的push_back
		void push_back(T&& x)
		{
			insert(_head, std::forward<T>(x)); //完美转发
		}
		//左值引用版本的insert
		void insert(node* pos, const T& x)
		{
			node* prev = pos->_prev;
			node* newnode = new node;
			newnode->_data = x;

			prev->_next = newnode;
			newnode->_prev = prev;
			newnode->_next = pos;
			pos->_prev = newnode;
		}
		//右值引用版本的insert
		void insert(node* pos, T&& x)
		{
			node* prev = pos->_prev;
			node* newnode = new node;
			newnode->_data = std::forward<T>(x); //完美转发

			prev->_next = newnode;
			newnode->_prev = prev;
			newnode->_next = pos;
			pos->_prev = newnode;
		}
	private:
		node* _head; //指向链表头结点的指针
	};
}

在这里插入图片描述
如果我们没有使用std::forward完美转发，会导致运行结果全是拷贝构造函数，即深拷贝。

_麦子熟了
关注
  • 12
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
专栏目录
详解C++11中的右值引用与移动语义
08-31
本篇文章主要介绍了详解C++11中的右值引用与移动语义，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
C++11 ——— 右值引用和移动语义
2021dragon的博客
09-07 3115
传统的C++语法中就有引用的语法，而C++11中新增了右值引用的语法特性，为了进行区分，于是将C++11之前的引用就叫做左值引用。但是无论左值引用还是右值引用，本质都是给对象取别名，左值引用就是对左值的引用，给左值取别名，通过“&”来声明，右值引用就是对右值的引用，给右值取别名，通过“&&”来声明。
【 C++11 】右值引用和移动语义
bit_zyx的博客
10-09 975
目录 1、基本概念 左值 vs 左值引用 右值 vs 右值引用 左值引用 vs 右值引用 2、右值引用使用场景和意义 左值引用的使用场景 左值引用的短板 右值引用和移动语义 ①、移动构造 ②、移动赋值 ③、编译器做的优化 ④、总结 右值引用引用左值 右值引用的
C++右值引用和移动语义
u012861978的专栏
02-15 54
当对一个包含资源的对象进行拷贝操作时，有深拷贝和浅拷贝两种方式，深拷贝需要申请新的资源，而浅拷贝是指将一个对象的值复制到另一个对象中，对于指针类型成员变量的拷贝，指针所指向的内存区域，并不进行复制，而是仅仅拷贝了指针本身。要做的事情也很简单，需要实现两个拷贝赋值函数，一个负责深拷贝，一个负责移动拷贝，其中深拷贝函数对应的参数是左值（当参数是左值时，调用深拷贝函数），移动拷贝函数对应的参数是右值（当参数是右值时，调用移动拷贝函数）。回顾之前我们对左值和右值的认识，右值表示一个临时值，左值表示一个非临时值。
C++-右值引用和移动语义
mrbone11的博客
10-07 961
文章目录右值引用和移动语义右值引用移动语义实现拷贝构造函数实现拷贝赋值函数类设计的局限性使用右值引用实现移动语义实现移动构造函数实现移动赋值函数何时使用移动语义其他移动构造函数不会被调用?如果 RVO 默认执行优化工作，我为什么要关心实现移动语义？我们在Holder示例中做了 RAII标记移动构造函数和移动赋值运算符为noexcept使用copy-and-swap进一步优化和增强异常安全性完美转发(forwarding) 右值引用和移动语义 右值引用 在 C++ 中，存在一些临时、生存期短的值，它们无法以任
C++右值引用与移动语义
qq_40982049的博客
06-17 174
c++右值引用与移动语义
【C++进阶】右值引用和移动语义
Ricky的博客
03-29 540
本文重点介绍了C++11的新特性右值引用和移动语义，已经与他们相关联的一些新特性，如：emplace_back和无序容器
深入解析C++右值引用和移动语义：编写更快、更节省内存的代码
Lion_Long的博客
10-18 1072
C++11 在性能上做了很大的改进，最大程度减少了内存移动和复制，通过右值引用、 forward、emplace 和一些无序容器我们可以大幅度改进程序性能。std::move强制转换为右值引用，触发移动构造函数，它的语法有&&。移动构造函数优先级高于拷贝构造函数。自己实现的类，要具备移动语义，必须自己实现移动构造函数。右值引用仅仅是通过改变资源的所有者来避免内存的拷贝，能大幅度提高性能。forward 能根据参数的实际类型转发给正确的函数。
c++之右值引用与移动语义
weixin_44031074的博客
11-05 347
c++11新增了一个新的特性：移动语义，这是一个非常有用的特性，今天我们就来了解一下这个特性。 右值引用 首先看下什么是右值引用。右值可以简单理解为可作用于等号右边的一类数据，它们有一个重要的特征：可以取其值不可以取其地址。 比如说13这个数字，不能对它进行取地址操作，也就是不能&13. 常见的右值有： 1.字面常量（c风格字符串除外） 2.函数返回值 3.类似于x+y这种类型的表达式 所谓右值引用也就是对右值进行引用。通过&&操作符完成 比如int &&x = 13
[C++]右值引用和移动语义
weixin_52345097的博客
06-28 293
本篇文章讲解了关于左值引用和右值引用的区别，以及为什么要有右值引用，并展示了右值引用的实际应用等。
右值引用和移动语义1
08-08
右值引用和移动语义1
深入了解c++11 移动语义与右值引用
08-18
主要介绍了c++ 移动语义与右值引用的相关资料，帮助大家更好的理解和学习c++,感兴趣的朋友可以了解下
【C++第三阶段】list容器&排序
最新发布
还有很多需要学习，现在还很菜
04-29 647
以下内容仅为当前认识，可能有不足之处，欢迎讨论！
《21天学通C++》（第十章）实现继承（1）
立志成为炼丹师？
04-28 254
覆盖是一种极端情况，即派生类中的重载方法会隐藏基类中方法的所有重载版本，导致需要调用时无法调用，示例代码如下。解决方法3：在派生类中，把基类中的方法全部重载一次，并在派生类中就调用基类方法。只要派生类中实现了从基类中继承的函数，且返回值和标值相同，就可以覆盖。如果基类包含重载的构造函数，可以使用初始化列表传递参数。，避免不定义的情况下，随机数值产生影响。解决办法1：使用作用域解析符。解决方法2：在派生类中使用。同样使用作用域解析运算符。在构造一个派生类时，使用作用域解析运算符。若想调用基类中的方法。
手搓顺序表（C语言）
m0_62646213的博客
04-23 767
顺序表头插头删，尾插尾删，任意位置插入删除的实现和优劣分析
c入门基础题（3）
梦昼初
04-26 934
1、找出数组中最大元素的位置（下标值） 输入 多组测试，每组先输入一个不大于10的整数n 然后是n个整数 输出 输出这n个整数中最大的元素及下标值 样例输入 4 1 4 5 6 样例输出 6 3 #include<stdio.h> int main(){ int a[20]; int n,x=0,y,z,s,m,f; int i,j; while(scanf("%d",&n)!=EOF){ for(i=1;i<=n;i++){ scanf("%d",&y)
C++相关概念和易错语法（9）（变量的存储、new和delete混用分析）
SGlow0708的博客
04-28 730
我们发现如果这个时候直接去调用operator delete[]、operator delete、delete、free就会导致释放的内存起始位置发生了位移，这就会导致报错，而delete[]就会先从前4个字节开始，先读取个数，然后。注意数组是开辟了空间的，会发生复制操作，就算是常量字符串储存在代码段，也要拷贝过来。如果类没有显式实现析构函数，那么就意味着不会多开辟那4个字节，也就不会报错，这个时候混用不会导致程序崩溃。当我们创建类的数组时，使用new[]，因为使用它可以在开辟空间的时候。
c++右值引用与移动语义
07-28
C++11引入了右值引用和移动语义的概念，这两个特性在处理对象的所有权转移和性能优化方面非常有用。 右值引用是一种新类型的引用，通过使用双 ampersand（&&）来声明。它主要用于绑定临时对象或将要被移动的对象。右值引用可以绑定到右值（临时对象、表达式结果等），但不能绑定到左值（具名对象）。 移动语义是使用右值引用来实现的。通过移动构造函数和移动赋值运算符，我们可以在不进行深拷贝的情况下将资源从一个对象转移到另一个对象。对于大型对象或资源密集型操作，这可以显著提高性能。 移动构造函数使用右值引用参数接收一个对象，并将其资源转移到新创建的对象中。移动赋值运算符也类似，允许将资源从一个对象转移到另一个对象。 使用移动语义的主要目的是避免不必要的拷贝操作。当我们需要在函数之间传递大型对象时，如果没有移动语义支持，传递过程中会进行深拷贝，导致性能下降。而使用移动语义，我们可以将资源直接转移给函数，避免了额外的拷贝开销。 总结一下，右值引用和移动语义是C++11引入的重要特性，可以实现对象所有权的转移和性能优化。它们在处理大型对象和资源密集型操作时非常有用，可以显著提高程序的效率。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

_麦子熟了

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值