当前位置： 首页 > news >正文

【C++篇】C++11：右值引用与移动语义

news 2025/8/6 10:40:36

文章目录

    • 一、左值引用和右值引用
    • 二、 右值引用使用场景和意义
      • 场景1：自定义类型中深拷贝的类，必须传值返回的场景
        • 回顾左值引用使用场景和意义
        • 左值引用的短板
        • 右值引用和移动语义解决左值引用的短板
        • 编译器优化机制
        • 对于自定义类型中浅拷贝的类，必须传值返回的场景，有必要去实现移动拷贝吗？
      • 场景2：对于容器的插入接口，插入对象是右值的场景
    • 三、完美转发
      • 万能引用
      • 完美转发保持值的属性

一、左值引用和右值引用

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

  • 左值：可以获取它的地址+可以对它赋值（修改）定义时const修饰符后的左值，不能给他赋值，但是可以取它的地址。
    左值既可以出现在=的左边，也可以出现在右边
  • 右值：右值不能取地址，也不能赋值（修改）
    右值可以出现在=的右边，但是不能出现出现在赋值符号的左边
int fmin(int a, int b)
{return a < b ? a : b;
}int main()
{// 以下都是左值int* p = new int(0);int b = 1;const int c = 2;"xxxxx";//注意常量字符串也是左值，因为它可以被取地址，const char* p = "xxxxx";p[2];//字符串字面值具有数组类型，是左值（尽管它是不可修改的左值）。// 以下几个都是常见的右值10;x + y;fmin(x, y);//函数的返回值是右值// 这里编译会报错：error C2106: “=”: 左操作数必须为左值10 = 1;x + y = 1;fmin(x, y) = 1;return 0;
}

什么是左值引用？什么是右值引用？

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

  • 对左值的引用就是左值引用，给左值取别名，定义方式：type&
  • 右值引用就是对右值的引用，给右值取别名，定义方式：type&& 
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;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);return 0;
}

需要注意的是：右值是不能取地址的，但给右值取别名后，会导致右值被存储到特定的位置，且可以取到该位置的地址，并且还可以去修改它，如果不想让被引用的右值被修改，可以用const修饰右值引用。

int main()
{double x = 1.1, y = 2.2;int&& rr1 = 10;const double&& rr2 = x + y;rr1 = 20;rr2 = 5.5; //报错return 0;
}

左值引用与右值引用比较

左值引用可以引用右值吗？
1. 左值引用只能引用左值，不能引用右值，因为右值是不能被修改的，而左值引用是可以修改，避免权限放大。
2. 但是const左值引用既可以引用左值，也可以引用右值。

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后的左值

int main()
{// 右值引用只能右值，不能引用左值。int&& r1 = 10;// error C2440: “初始化”: 无法从“int”转换为“int &&”// message : 无法将左值绑定到右值引用int a = 10;int&& r2 = a;// 右值引用可以引用move以后的左值int&& r3 = std::move(a);return 0;
}

二、 右值引用使用场景和意义

为了更好的说明问题，这里需要借助一个深拷贝的类，下面模拟实现了一个简化版的string类。类当中实现了一些基本的成员函数，并在string的拷贝构造函数和赋值运算符重载函数当中打印了一条提示语句，这样当调用这两个函数时我们就能够知道。

代码如下：

class string
{
public:typedef char* iterator;iterator begin(){return _str;}iterator end(){return _str + _size;}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;}const char* c_str() const{return _str;}
private:char* _str;size_t _size;size_t _capacity; // 不包含最后做标识的\0
};

代码说明：由于operator=()用的是现代写法（调用拷贝构造），因此调用他会打印两次深拷贝信息，这里我们要视为一次深拷贝，

场景1：自定义类型中深拷贝的类，必须传值返回的场景

回顾左值引用使用场景和意义

左值引用使用场景：

  1. 做函数的参数
  2. 做函数的返回值
    价值：减少拷贝构造，提升效率。
void func1(string s)
{}void func2(const string& s)
{}int main()
{string s1("hello world");// func1和func2的调用我们可以看到左值引用做参数减少了拷贝，提高效率的使用场景和价值func1(s1);func2(s1);// string operator+=(char ch) 传值返回存在深拷贝// string& operator+=(char ch) 传左值引用没有拷贝提高了效率s1 += '!';return 0;
}
左值引用的短板

左值引用虽然能避免不必要的拷贝操作，但左值引用并不能完全避免：
当函数返回对象是一个局部变量，出了函数作用域就不存在了，就不能使用左值引用返回，只能传值返回。

string func()
{string str("woxiangchiyu");//cin >> str;//....return str;
}int main()
{string ret1 = func();return 0;
}

无奈只能含泪拷贝构造两次，如果拷贝对象较大，将是一笔不小的开销。

图解说明：因为operator=()用的是现代写法（调用拷贝构造），所以这里暂且将其与拷贝构造归为一类。
在这里插入图片描述
C++11新增的右值引用就是为了解决左值引用的短板的，但并不是简单的将右值引用作为函数的返回值。

右值引用和移动语义解决左值引用的短板

移动构造：
移动构造本质是将参数右值的资源窃取过来，占位已有，那么就不用做深拷贝了，所以它叫做移动构造，就是窃取别人的资源来构造自己，并将自己原本的无用资源再交给别人，顺便让别人再帮忙释放自己的资源。说白了，就是和目标对象进行资源交换

在当前的string类中增加一个移动构造函数，该函数要做的就是调用swap函数将传入右值的资源窃取过来，为了能够更好的得知移动构造函数是否被调用，可以在该函数当中打印一条提示语句。

// 移动构造
string(string&& s):_str(nullptr),_size(0),_capacity(0)
{cout << "string(string&& s) -- 移动语义" << endl;swap(s);
}//拷贝构造函数
string(const string& s):_str(nullptr), _size(0), _capacity(0)
{cout << "string(const string& s) -- 深拷贝" << endl;string tmp(s._str);swap(tmp); 
}

移动构造VS拷贝构造

  • 在没有增加移动构造之前，由于拷贝构造采用的是const左值引用接收参数，因此无论拷贝构造对象时传入的是左值还是右值，都会调用拷贝构造函数。
  • 增加移动构造之后，由于移动构造采用的是右值引用接收参数，因此如果拷贝构造对象时传入的是右值，那么就会调用移动构造函数（匹配原则）。
  • string的拷贝构造函数做的是深拷贝，而移动构造函数是调用swap函数进行资源的转移，本质上是浅拷贝。因此，移动构造比拷贝构造的代价低得多。

移动赋值：
与移动构造是同理的，这里平移过来理解即可

在该函数当中打印一条提示语句。

//移动赋值
string& operator=(string&& s)
{cout << "string& operator=(string&& s) -- 移动赋值" << endl;swap(s);return *this;
}//赋值运算符重载（现代写法）
string& operator=(const string& s)
{cout << "string& operator=(const string& s) -- 深拷贝" << endl;string tmp(s); swap(tmp); return *this; 
}

我们将右值分为两类：

  1. 内置类型的右值，称作纯右值
  2. 自定义类型的右值，称作将亡值
  • 当函数返回值是一个将亡值时，编译器就会调用移动拷贝
  • 当函数返回值是一个左值时，编译器就会调用深拷贝

比如：

在这里插入图片描述
我们来看看运行结果：
需要注意的是，现在C++拥有RVO优化机制： 。

  • 当函数返回一个局部对象时（如 func() 中的 str），编译器会直接在调用方的内存位置构造这个对象（即 ret1），跳过拷贝/移动构造。
  • 在 main() 中：
string ret1 = func();  // 直接构造 ret1，无额外拷贝

编译器将 ret1 的地址传递给 func()，让 func() 在其内部直接将 str 构造到 ret1 的内存中，避免临时对象的创建和拷贝。

但是我们可以显式使用 std::move，阻止 RVO，去调用我们的拷贝函数：

string func()
{string str("woxiangchiyu");//cin >> str;//....return move(str);//显式使用 std::move
}

小插曲：
这个RVO机制属实让我有点绷不住了🤮，因为我学习的视频是一两年前的，那时应该是还没有RVO，我照例运行出来发现是空的，然后我就找错，代码看了两三遍，我终于开始怀疑是编译器从中做鬼，然后一查果然是！不得不感叹一下，如今编译器优化程度真是有点逆天了。

在这里插入图片描述
可以看到，运行结果与我们图中分析的不太一样。
其实是编译器优化后导致的结果。

编译器优化机制

我们知道，对于连续拷贝时，编译器会优化为只拷贝一次

  1. 右值对象构造，只有拷⻉构造，没有移动构造的场景：
    在这里插入图片描述
    运行截图：
    在这里插入图片描述

但是，当创建对象与赋值分离时：

string func()
{string str("woxiangchiyu");//cin >> str;//....return str;
}int main()
{string ret1;ret1 = func();return 0;
}

编译器无法优化，因为拷贝不是连续的了。
运行截图：
在这里插入图片描述

  1. 右值对象构造，有拷贝构造，也有移动构造的场景

编译器优化了两处：

  • 连续构造/拷贝构造，合二为一
  • 将str识别为右值（将亡值）
    尽管str在函数中为左值，当却是一个将亡值，因此将其视为右值合情合理。
    在这里插入图片描述
    当创建对象与赋值分离时：
    编译器也能优化：将str识别为右值（将亡值）
    但无法优化连续拷贝/构造问题。运行截图：
    在这里插入图片描述
对于自定义类型中浅拷贝的类，必须传值返回的场景，有必要去实现移动拷贝吗？

  • 明确右值引用的核心价值：相对于左值引用，进一步减少拷贝，弥补左值引用没有解决的场景。

  • 对于浅拷贝的类，比如Date类，它的成员变量均为内置类型，拷贝构造的代价不大，只是对成员变量赋值。

  • 如若非要实现移动拷贝，交换内置类型的资源的本质也是对成员变量赋值，和拷贝构造没有任何效率提升，那我们又何苦白费力气的去添加移动拷贝呢？

因此，浅拷贝的类不需要实现移动构造，传值返回的拷贝代价也并不大。

场景2：对于容器的插入接口，插入对象是右值的场景

我们知道，C++11标准出来之后，STL容器插入接口函数也增加了右值引用版本。

添加右值引用版本插入函数的意义

以list容器的push_back为例：
在这里插入图片描述
我们知道，list的push_back接口的实现逻辑是：先构造一个结点，然后再将该结点插入到底层的双链表当中。

//左值引用版本
void push_back(const string& val)
{Node* newnode = new Node(val);//…………
}//右值引用版本
void push_back(string&& val)
{//这里的forward<T>(val)是完美转发//目的是使val为右值，至于为什么val会为左值，后文完美转发会详细讲解Node* newnode = new Node(forward<T>(val));//…………
}

我们插入左值和右值：

int main()
{list<string> lt;string s("woxiangchiyu");lt.push_back(s);//插入左值//插入右值lt.push_back(move(s));lt.push_back("111111");lt.push_back(string("222222"));//匿名对象return 0;
}
  • 插入左值，在push_back函数中构造结点时，这个左值只能匹配到string的拷贝构造函数进行深拷贝。
  • 插入右值，在push_back函数中构造结点时，这个右值就可以匹配到string的移动构造函数进行资源的转移，这样就避免了深拷贝，提高了效率。
    注意：前提是string类提供了移动构造函数，并且list容器的push_back接口提供了右值引用版本

函数调用图解：
在这里插入图片描述
运行结果：
在这里插入图片描述
总结：容器的插入接口，如果对象是右值，可以利用移动构造转移资源给数据结构的对象，也可以减少拷贝构造，提升效率。

三、完美转发

万能引用

模板中的&&不是右值引用，而是万能引用，既可以接收左值，又可以接收右值。

template<class T>
void PerfectForward(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)
{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;
}

运行结果截图：
在这里插入图片描述
原来，为了使得右值的资源能够被转移，编译器不得不将右值引用的属性识别为左值。

在这里插入图片描述
但是如果需要引用的属性不发生变化：右值引用就是右值、左值引用就是左值。有什么解决方案呢？

完美转发功能正在于此，在需要保持原本属性的引用x上使用：forward<T>(x)即可
如下：

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(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是何缘由了，这是完美转发的一个重要场景，不仅如此，list的insert、ListNode的构造都需用到完美转发。

注意：STL的每个容器都有对应的实现，这里只是以list举例。

http://www.lryc.cn/news/610989.html

相关文章：

  • mac安装pycharm
  • CVPR优秀论文 | DashGaussian：在200秒内优化三维高斯点绘制
  • 蓝桥杯常用java API
  • 『 C++ 入门到放弃 』- 智能指针
  • 飞算JavaAI—AI编程助手 | 引领开发新时代，智能化编程的完美助手
  • 从「同步」到「异步」：用 aiohttp 把 Python 网络 I/O 榨到极致
  • Vue.js之核心语法与指令
  • 网络 —— 笔记本(主机)、主机虚拟机(Windows、Ubuntu)、手机(笔记本热点)，三者进行相互ping通
  • 初始MyBatis
  • LabVIEW 2025 安装攻略（附图文教程）适用于测试与自动控制领域
  • MySQL 查询性能优化与索引失效问题全解析
  • 使用公众号的消息模板给关注用户发消息
  • MySQL CONV()函数
  • spring webflux链路跟踪【traceId日志自动打印】
  • 移动端 WebView 调试实战 深色模式样式失效与主题切换异常排查指南
  • 前端1.0
  • Lua语言程序设计1：基础知识、数值、字符串与表
  • 针对软件定义车载网络的动态服务导向机制
  • linux_https，udp，tcp协议（更新中）
  • 实战项目3-工控软件-2.0- 自定义控件HMILabel的创建
  • 漏洞分析：90分钟安全革命
  • 赛灵思ZYNQ官方文档UG585自学翻译笔记：Quad-SPl Flash 闪存控制器
  • 信息系统项目管理中的沟通管理实战精解
  • 智慧油站误报率↓77%：陌讯多模态融合算法实战解析
  • 【Git】git提交代码报错Git: husky ＞ pre-commit
  • 【Java面试题】注解，异常相关知识
  • 二维数点问题 1
  • Dell电脑Windows系统更新后声卡驱动无法识别插线耳机问题
  • 第13届蓝桥杯Scratch_选拔赛_初级组_真题2022年1月22日
  • leetcode-python-删除链表的倒数第 N 个结点