C++11——右值引用和移动语义

我的代码爱吃辣2023-09-02 2:35

✅<1>主页：：我的代码爱吃辣

📃<2>知识讲解：C++11------右值引用

☂️<3>开发环境：Visual Studio 2022

💬<4>前言：右值引用，是C++11更新的一个非常有价值的语法，可以说是C++为了追求极致的性能而出现的，以前我们非常惧怕，自定义类型的传值返回，有了右值引用就还很多了。

目录

一.左值引用和右值引用

1.左值引用和右值引用

2.什么是右值？什么是右值引用？

[二. 左值引用与右值引用比较](#二. 左值引用与右值引用比较)

三.右值引用使用场景和意义

1.移动构造

2.移动赋值

3.STL中的容器都是增加了移动构造和移动赋值：

[​编辑 四. 右值引用引用左值及其一些更深入的使用场景分析](#编辑 四. 右值引用引用左值及其一些更深入的使用场景分析)

[五. 完美转发](#五. 完美转发)

[1.模板中的&& 万能引用](#1.模板中的&& 万能引用)

[2.std::forward 完美转发在传参的过程中保留对象原生类型属性](#2.std::forward 完美转发在传参的过程中保留对象原生类型属性)

3.完美转发实际中的使用场景

一.左值引用和右值引用

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

1.左值引用和右值引用

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

值，不能给他赋值，但是可以取它的地址。左值引用就是给左值的引用，给左值取别名。

cpp 复制代码 
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;
}

2.什么是右值？什么是右值引用？

右值也是一个表示数据的表达式，如：字面常量、表达式返回值，函数返回值(这个不能是左值引

用返回)等等，**右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能
取地址。**右值引用就是对右值的引用，给右值取别名。

cpp 复制代码 
int fmin(int a, int b)
{
	return a;
}
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被修改，可以用const int&& rr1 去引用，是不是感觉很神奇，

这个了解一下实际中右值引用的使用场景并不在于此，这个特性也不重要。

二. 左值引用与右值引用比较

左值引用总结：

  1. 左值引用只能引用左值，不能引用右值。
  2. 但是const左值引用既可引用左值，也可引用右值。
cpp 复制代码 
int main()
{
	// 左值引用只能引用左值，不能引用右值。
	int a = 10;
	int& ra1 = a;  // ra为a的别名
	//int& ra2 = 10;  // 编译失败，因为10是右值
	// const左值引用既可引用左值，也可引用右值。
	const int& ra3 = 10;
	const int& ra4 = a;
	return 0;
}

右值引用总结：

  1. 右值引用只能右值，不能引用左值。
  2. 但是右值引用可以move以后的左值。
cpp 复制代码 
int main()
{
	// 右值引用只能右值，不能引用左值。
	int&& r1 = 10;
	// error C2440: "初始化": 无法从"int"转换为"int &&"
	// message : 无法将左值绑定到右值引用
	int a = 10;
	int&& r2 = a;
	// 右值引用可以引用move以后的左值
	int&& r3 = std::move(a);
	return 0;
}

三.右值引用使用场景和意义

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

1.移动构造

cpp 复制代码 
#include<cassert>
namespace ikun
{
	class string
	{
	public:
		string(const char* str = "")
			:_size(strlen(str))
			, _capacity(_size)
		{
			//cout << "string(char* str)构造函数" << endl;
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}
		// s1.swap(s2)
		void swap(string& s)
		{
			::swap(_str, s._str);
			::swap(_size, s._size);
			::swap(_capacity, s._capacity);
		}
		// 拷贝构造
		string(const string& s)
			:_str(nullptr)
		{
			cout << "string(const string& s) -- 深拷贝---拷贝构造" << endl;
			string tmp(s._str);
			swap(tmp);
		}
		// 赋值重载
		string& operator=(const string& s)
		{
			cout << "string& operator=(string s) -- 深拷贝---赋值重载" << endl;
			string tmp(s);
			swap(tmp);
			return *this;
		}

		~string()
		{
			delete[] _str;
			_str = nullptr;
		}
		char& operator[](size_t pos)
		{
			assert(pos < _size);
			return _str[pos];
		}
		void reserve(size_t n)
		{
			if (n > _capacity)
			{
				char* tmp = new char[n + 1];
				strcpy(tmp, _str);
				delete[] _str;
				_str = tmp;
				_capacity = n;
			}
		}
		void push_back(char ch)
		{
			if (_size >= _capacity)
			{
				size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
				reserve(newcapacity);
			}

			_str[_size] = ch;
			++_size;
			_str[_size] = '\0';
		}
		//string operator+=(char ch)
		string& operator+=(char ch)
		{
			push_back(ch);
			return *this;
		}

		// string+
		string operator+(char ch)
		{
			ikun::string str(this->c_str());
			str.push_back(ch);
			return str;
		}

		const char* c_str() const
		{
			return _str;
		}
	private:
		char* _str;
		size_t _size;
		size_t _capacity; // 不包含最后做标识的\0
	};
}

int main()
{
	ikun::string str("1111");
	ikun::string str1 = str + 'A';

	return 0;
}

这种情况下避免避免不了的深拷贝。

如果我们有移动构造：

首先我们先思考一个下面这个问题？

答:次数的str是一个局部变量，除了作用域就会销毁，如果我们得到他的引用，再次访问时就是非法的访问了。所以str只能作为传值返回，但是传值返回有一个，返回执行之后，函数调用结束，函数栈帧销毁，伴随的局部变量也就销毁了，编译器在处理时，会使用一个临时变量来存储返回值。如果外面有接收再拷贝给外面，这就是我们看到的图上画的两层拷贝构造。

右值也可以分为两种：

  • 纯右值：字面量，等。
  • 将亡值：比如这里的返回的局部变量 str。

移动构造顾名思义，可以将将亡值的资源移动到新的对象里，从而节省拷贝得代价。

我们通过查看底层字符串的地址来进一步观察资源移动：

cpp 复制代码 
int main()
{
    ikun::string str("123");
    printf("str:%p\n", str.c_str());
    //将str强制变成右值
    ikun::string str1(move(str));
    printf("str:%p\n", str1.c_str());

    return 0;
}

注意：这里我们把s1 move处理以后, 会被当成右值，调用移动构造但是这里要注意，一般是不要这样用的，因为我们会发现s1的资源被转移给了s3，s1被置空了。

cpp 复制代码 
// 移动构造
string(string&& s)
	:_str(nullptr)
	, _size(0)
	, _capacity(0)
{
	cout << "string(string&& s) -- 移动语义---移动构造" << endl;
	swap(s);
}

2.移动赋值

cpp 复制代码 
#include<cassert>
namespace ikun
{
	class string
	{
	public:
		string(const char* str = "")
			:_size(strlen(str))
			, _capacity(_size)
		{
			//cout << "string(char* str)构造函数" << endl;
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}
		// s1.swap(s2)
		void swap(string& s)
		{
			::swap(_str, s._str);
			::swap(_size, s._size);
			::swap(_capacity, s._capacity);
		}
		// 拷贝构造
		string(const string& s)
			:_str(nullptr)
		{
			cout << "string(const string& s) -- 深拷贝---拷贝构造" << endl;
			string tmp(s._str);
			swap(tmp);
		}
		// 赋值重载
		string& operator=(const string& s)
		{
			cout << "string& operator=(string s) -- 深拷贝---赋值重载" << endl;
			string tmp(s);
			swap(tmp);
			return *this;
		}
		// 移动构造
		string(string&& s)
			:_str(nullptr)
			, _size(0)
			, _capacity(0)
		{
			cout << "string(string&& s) -- 移动语义---移动构造" << endl;
			swap(s);
		}

		~string()
		{
			delete[] _str;
			_str = nullptr;
		}
		char& operator[](size_t pos)
		{
			assert(pos < _size);
			return _str[pos];
		}
		void reserve(size_t n)
		{
			if (n > _capacity)
			{
				char* tmp = new char[n + 1];
				strcpy(tmp, _str);
				delete[] _str;
				_str = tmp;
				_capacity = n;
			}
		}
		void push_back(char ch)
		{
			if (_size >= _capacity)
			{
				size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
				reserve(newcapacity);
			}

			_str[_size] = ch;
			++_size;
			_str[_size] = '\0';
		}
		//string operator+=(char ch)
		string& operator+=(char ch)
		{
			push_back(ch);
			return *this;
		}

		// string+
		string operator+(char ch)
		{
			ikun::string str(this->c_str());
			str.push_back(ch);
			return str;
		}

		const char* c_str() const
		{
			return _str;
		}
	private:
		char* _str;
		size_t _size;
		size_t _capacity; // 不包含最后做标识的\0
	};
}

int main()
{
	ikun::string str("1111");
	str = ikun::string("123");

	return 0;
}

移动复制和移动构造基本一致：

cpp 复制代码 
// 移动赋值
string& operator=(string&& s)
{
	cout << "string& operator=(string&& s) -- 移动语义---移动赋值" << endl;
	swap(s);
	return *this;
}

3.STL中的容器都是增加了移动构造和移动赋值：

四. 右值引用引用左值及其一些更深入的使用场景分析

按照语法，右值引用只能引用右值，但右值引用一定不能引用左值吗？因为：有些场景下，可能

真的需要用右值去引用左值实现移动语义。当需要用右值引用引用一个左值时，可以通过move
函数将左值转化为右值。 C++11中，std::move()函数位于<utility> 头文件中，该函数名字具有迷惑性，它并不搬移任何东西，唯一的功能就是将一个左值强制转化为右值引用，然后实现移动语义。

STL容器插入接口函数也增加了右值引用版本：

cpp 复制代码 
#include<list>
int main()
{
	list<ikun::string> lt;
	ikun::string s1("1111");
	// 这里调用的是拷贝构造
	lt.push_back(s1);
	// 下面调用都是移动构造
	lt.push_back("2222");
	lt.push_back(std::move(s1));
	return 0;
}

五. 完美转发

1.模板中的&& 万能引用

模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值，模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力，但是引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值，我们希望能够在传递过程中保持它的左值或者右值的属性, 就需要用我们下面学习的完美转发。

cpp 复制代码 
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;
}

模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力，但是引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值。所以这里都是左值在调用函数Fun（）；

2.std::forward 完美转发在传参的过程中保留对象原生类型属性

cpp 复制代码 
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(std::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;
	
}

3.完美转发实际中的使用场景

cpp 复制代码 
template<class T>
struct ListNode
{
	ListNode* _next = nullptr;
	ListNode* _prev = nullptr;
	T _data;
};
template<class T>
class List
{
	typedef ListNode<T> Node;
public:
	List()
	{
		_head = new Node;
		_head->_next = _head;
		_head->_prev = _head;
	}
	void PushBack(T&& x)
	{
		//Insert(_head, x);
		Insert(_head, std::forward<T>(x));// 关键位置
	}
	void PushFront(T&& x)
	{
		//Insert(_head->_next, x);
		Insert(_head->_next, std::forward<T>(x));// 关键位置
	}
	void Insert(Node* pos, T&& x)
	{
		Node* prev = pos->_prev;
		Node* newnode = new Node;
		newnode->_data = std::forward<T>(x); // 关键位置
		// prev newnode pos
		prev->_next = newnode;
		newnode->_prev = prev;
		newnode->_next = pos;
		pos->_prev = newnode;
	}
	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;
	}
private:
	Node* _head;
};
相关推荐
万物得其道者成12 分钟前
React Zustand状态管理库的使用
开发语言·javascript·ecmascript
学步_技术18 分钟前
Python编码系列—Python抽象工厂模式：构建复杂对象家族的蓝图
开发语言·python·抽象工厂模式
BeyondESH40 分钟前
Linux线程同步—竞态条件和互斥锁(C语言)
linux·服务器·c++
wn53142 分钟前
【Go - 类型断言】
服务器·开发语言·后端·golang
豆浩宇1 小时前
Halcon OCR检测 免训练版
c++·人工智能·opencv·算法·计算机视觉·ocr
Hello-Mr.Wang1 小时前
vue3中开发引导页的方法
开发语言·前端·javascript
救救孩子把1 小时前
Java基础之IO流
java·开发语言
WG_171 小时前
C++多态
开发语言·c++·面试
宇卿.1 小时前
Java键盘输入语句
java·开发语言
Amo Xiang1 小时前
2024 Python3.10 系统入门+进阶（十五）：文件及目录操作
开发语言·python
热门推荐
01RAG 实践- Ollama+RagFlow 部署本地知识库02组基轨迹建模 GBTM的介绍与实现（Stata 或 R）032024年高教社杯数学建模国赛C题超详细解题思路分析04Coze扣子平台完整体验和实践（附国内和国际版对比）05苍穹外卖面试总结06【2024数模国赛赛题思路公开】国赛B题思路丨附可运行代码丨无偿自提07yolov8实战第五天——yolov8+ffmpg实时视频流检测并进行实时推流——（推流，保姆教学）08CCF-CSP认证考试 202406-3 文本分词 100分题解09【2024高教社杯全国大学生数学建模竞赛】B题 生产过程中的决策问题——解题思路 代码 论文10浏览器插件——ModHeader 的分享和学习