【C++】C++11的新特性 --- 右值引用与移动语义

🕗 发布于 2024-07-19 10:17 c++ java android 数据结构 c语言

在这里插入图片描述

假如生活欺骗了你

不要悲伤，不要心急！

忧郁的日子里须要镇静

相信吧

快乐的日子将会来临

-- 普希金《假如生活欺骗了你》

C++11的新特性

1 左值与右值
2 左值引用和右值引用
3 引用的意义
4 移动语义
5 万能引用和完美转发
Thanks♪(･ω･)ﾉ谢谢阅读！！！
下一篇文章见！！！

1 左值与右值

C++中，一个表达式不是右值就是左值。C语言中：左值可以位于赋值对象的左边，右值则不能。在C++中就没有这么简单了。在C++中的左右值可以通过是否可以取地址来区分：

左值表示一个占据内存中可识别位置的一个对象，有可能是一个表达式。更进一步地，可以对左值取地址
右值即不能进行取地址的值或表达式。包括常量，加减乘除等表达式，临时对象。

PS:左值和右值在内存中都是有地址的，只有左值可以取地址！

左值包括变量名，解引用的指针的等。下面是比较经典的左值，他们都可以进行取地址操作！
注意左值引用和右值引用都是左值

int a = 1;
int* p = &a;
int** pp = &p;
const int b = 2;

右值一般是常量，表达式，临时变量 ,对于一个常量肯定是无法取地址的！

&10;
&(1 + 1);
&string("111");

当一个对象被作为右值进行使用时，用的是对象的值（内容）；用做左值时，实际使用的是对象的身份（在内存中的位置）

2 左值引用和右值引用

左值引用就是对左值进行取别名：

int a = 1;    int& ra = a;
int* p = &a;int*& rp = p

右值引用就是对右值进行取别名：

int&& rra = (1 + 1);
string&& rrb = string("111");
string&& rrb = to_string(111);

左值引用不可以给右值取别名，但是const左值引用可以

const int& ra = 10;
const string& rb = string("111");

右值引用不可以对左值取别名，但是可以给move后的左值取别名.move也是C++11新加入的特性，我们后面讲。

3 引用的意义

在之前，我们使用引用的目的是什么？是为了减少拷贝，提高性能。

void func1(const string& s);//传引用参数
string& func2(const string& s);//传引用返回

但是，引用返回也会出现一些问题，比如一个函数返回临时变量的引用，这时就会出错。临时变量的生命周期只在func2函数，func2函数返回一个临时变量的引用,在函数执行结束，临时变量就会进行销毁！右值引用也无法解决生命周期的问题！

那右值引用的意义在哪里呢？？？
我们来看一个情景：(bit::string是自己写的string类，方便看效果)

bit::string ret1 = bit::to_string(1234);

这个会进行几次深拷贝？
在这里插入图片描述
按理来说，应该会会进行两次拷贝构造，首先拷贝构造临时变量，然后ret1在拷贝构造。但是编译器进行了一个优化，实际上只进行了一次拷贝构造。

当我们把这个表达式分开写，就不会进行优化了,没有办法合二为一

bit::string ret1;
ret1 = to_string(1234);

这两种情况的拷贝的代价都挺大，有没有一种简单的解决办法来避免进行深拷贝？
这里可不能使用左值引用，因为临时变量在该行函数结束就销毁，在主函数里会直接挂掉！使用右值引用会直接报语法错误，因为在to_string中返回值是一个左值，左值是不能被右值引用的！
如果将该左值进行move()他就可以被右值引用。

bit::string&& to_string(int val)
{
bit::string str;
//...
//处理
//...
return move(str);
}

这样运行依旧会挂掉，因为右值引用也是别名，**无法解决生命周期的问题！**这里左值引用和右值引用是没有区别的！
栈桢图是这样的：
在这里插入图片描述
编译器优化后会只进行一次拷贝构造ret1，但还是进行了深拷贝！

所以这个深拷贝的问题无法通过左值引用或者右值引用来解决！所以就有了移动语义！

4 移动语义

4.1 移动构造与移动赋值

C++11中就加入了一个针对右值引用的拷贝构造 — 移动构造！

PS:左值引用是拷贝构造，右值引用是移动构造！— 构成函数重载

//拷贝构造 --- const 左值可以接收左值和右值
string(const string& s) :
_str(new char[s._capacity + 1])
,_size(0)
,_capacity(0)
{
cout << "string(const string& s = "")  --- 深拷贝" << endl;
strcpy(_str, s._str);
_size = s._size;
_capacity = s._capacity;
}
//移动构造
string(string&& s)
:_str(nullptr)
{
cout << "string(string&& s) --- 移动构造" << endl;
swap(s);
}

上面我们已经知道了右值引用的的一般类型：匿名对象，传值返回的临时对象

int&& rra = (1 + 1);
string&& rrb = string("111"); //匿名对象
string&& rrb = to_string(111);//传值返回的临时对象

这里进行一下跟细致的区分：纯右值和将亡值

纯右值：内置类型的右值引用是纯右值：int&& a == 10 ；int&& b = (1 + 1);
将亡值：自定义类型的右值引用，生命周期只有一行。

分析一下左值的拷贝构造，因为传入的是一个左值，其有自己的内存中的位置，不能修改！必须进行深度的拷贝。但是如果是一个右值，是一个临时变量的右值引用（将亡值），其生命周期就一行，就可以对其进行修改！

string(string&& s)
:_str(nullptr)
{
swap(s);//直接将亡值的替换就可以
}

直接进行替换不就可以了？反正也是将亡的，不用他就直接销毁了，怪可惜的！
在这里插入图片描述

**移动构造就是用来解决这个问题的！**通过to_string返回的对左值的move的右值引用,就会调用到移动构造，就避免了深拷贝！（PS:不显式加上move也会调用到移动构造，编译器的优化很强，会强行识别成右值进而进行移动构造！）
在这里插入图片描述

移动构造的代价是很低的，因为是使用的同一块地址，没有开辟新的空间！注意移动构造只能对右值进行处理！必须是将亡值才有可以进行移动构造！
再来看个例子


int main()
{
string s1("1111111111111111111");
string s2 = s1;
string s3 = move(s1);
}

s2是拷贝构造，开辟了新空间。s3进行移动构造，导致S1和空的s3进行了交换，s1变成了空！

对于分开书写的两行代码，编译器也无法进行优化，会进行两次深拷贝！而有了移动构造和移动赋值，都是对一块资源的移动，成本很低！ 移动构造彻底解决传值返回的性能问题!!!
在这里插入图片描述
这里有点像拷贝的现代写法，但是拷贝的现代写法的本质还是开辟空间！

我们来看一个实际使用中的代吗：杨辉三角

class Solution {
public:
    vector<vector<int>> generate(int numRows) {
        vector<vector<int>> vv(numRows) ;

        for(int i = 0;i < numRows ;i++){

            vv[i].resize(i + 1);
            if(i == 0) {
                vv[i][0] = 1;
            }
            else if(i == 1){
                vv[i][0] = vv[i][1] = 1;
            }
            else{
                vv[i][0] =  vv[i][i] = 1;
                for(int j = 1 ;j < i ;j++){
                    vv[i][j] = vv[i - 1][j - 1] + vv[i - 1][j];
                }
            }
        }
        return vv;
    }
};

int main()
{
vector<vector<int>> ret;
ret = Solution.generate(1000);
return 0; 
}

这段代码是很坑的，我们来分析一下：

首先杨辉三角中的核心是二维数组：vector<vector<int>>，这就注定其深拷贝的时间复杂度是O(n^2)。
然后返回值是传值返回？这在调用的时候很明显会创建临时变量，就会进行深拷贝！

这就导致使用的之后传入一个较大数1000,会进行两次深拷贝,每次深拷贝的代价都很大！

所以实践中不能写这样的代码，可以改成：

class Solution {
public:
     void generate(int numRows , vector<vector<int>>& vv) {

    }
};

这样可以避免临时变量的深拷贝。在C++11之前都是这样保证效率，现在当然最好还是使用右值引用+移动赋值来解决。直接进行资源的转移，避免不必要的深拷贝！编译器会自动将返回值识别成右值，进而进行移动辅助！

4.2 区分现代写法与移动语义

我们先来看赋值重载的现代写法：

string& operator=(const string& s) {
//现代写法
string tmp(s);
swap(tmp);
return *this;
}

现代写法并没有减小成本，本质还是进行了深拷贝，传入的还是左值。没有性能的提升。
再来看移动赋值

string& operator=(string&& s) {
swap(s);
return *this;
}

因为传入的是这里只进行了一次资源的交换，没有进行深拷贝，对性能有很大的提升！

4.3 实践中落实移动语义

前面我们说过：左值引用和右值引用都是左值。我们可以来验证一下：

using namespace std;
//函数重载
void func(string& s) 
{
cout << "func(string& s)  --- 左值引用" << endl;
}
void func(string&& s)
{
cout << "func(string& s)  --- 右值引用" << endl;
}

int main()
{
string s("111");
string& s1 = s;
string&& s2 = string("111");
func(s1);
func(s2);
}

我们运行看看：
在这里插入图片描述
左值引用和右值引用都匹配到了左值引用的函数，证明了左值引用和右值引用都是左值。只有这样才能逻辑自洽！
回看移动赋值,在里面to_string的返回值成为string&& s，里面进行了一步swap(s)。我们又知道右值本身是不能被改变的，如果右值引用作为了一个右值的别名是右值的话，那么还是不能进改变，那如何进行资源的转移呢？
在这里插入图片描述
只有右值引用本身是左值，才能实现移动构造和移动赋值中的资源转移！！！
这实现了逻辑的自洽：右值引用的属性如果是右值，那么移动构造和移动赋值要进行转移资源的语法就是矛盾的，右值是不能进行改变的（可以理解为右值自带const属性），右值是有空间存储的，只是语法不允许取地址，但是是可以想办法取到的!
强转和再次引用（先转换为左值）都可以取到

string&& s2 = string("111");
string& s3 = s2;

string& s4 = (string&)string("111");

理解上述内容，接下来我们就来看List中如何使用移动语义
我们来看push_back()
C++11中增添了右值引用版本的
在这里插入图片描述
我们来底层中来细细品味：

我们进行插入string是进行了一次构造和深拷贝，这是list内部push_back()中创建新节点中会创建一个string，然后进行拷贝。里面s1是左值，所以进行的是深拷贝！！！我们换一种方式
在这里插入图片描述
这样在节点创建中创建string进行了一次构造，然后就是移动构造了，因为这里是匿名对象，是一个将亡值，编译器自动匹配了移动构造！所以我们在平时写代码中使用匿名对象会使效率更高!!!

然后我们来自己实现一下：
在这里插入图片描述
首先我们看到我们初始化一个list会进行一次构造和深拷贝，这是因为头结点的缘故。而STL库中的是使用内存池（没有初始化），所以不会打印出来。
我们赶紧来看push_back，如果只有一个左值引用的版本，无论左值还是右值都只能调用这个。我们加一个右值版本：

void push_back(const T& x = T())
{
//找尾
insert(end(), x);
}
void push_back(T&& x)
{
//找尾
insert(end(), x);
}

我们试试
在这里插入图片描述
哎嘿！？怎么插入右值和插入左值都是深拷贝啊？其实我们看一下push_back中调用的insert就明白了。push_back支持右值了，可是insert还没有右值的版本啊！我们还要补充insert的右值版本

//右值版本
void insert(iterator pos = begin(), T&& x = T())
{
Node* prev = pos._node->_prev;
Node* next = pos._node;

Node* node = new Node(x);

node->_prev = prev;
node->_next = next;
prev->_next = node;
next->_prev = node;

_size++;

}

再来看看：
在这里插入图片描述
哎？还是这样？为什么呢？我们在分析分析insert内部，其中的Node* node = new Node(x);这一步会调用node的构造函数，而node还没有支持右值引用的移动构造啊！所以我们还要为节点增添一个移动构造

ListNode(T&& x ) :
_next(nullptr),
_prev(nullptr),
_data(x)
{}

这样移动构造内部会调用_data的构造，而这里_data是string我们已经写好了移动构造，那这次应该就可以了吧？
在这里插入图片描述
答案是 NO!!!
还记得上面说过：左值引用和右值引用都是左值!

第一层的push_back()是可以调用到右值引用的版本，第二次的insert()的第二个参数无论是左值引用还是右值引用，都只会调用左值版本？这要怎么解决呢？我们可以进行move！

void push_back(T&& x)
{
insert(end(), move(x));
}

void insert(iterator pos = begin(), T&& x = T())
{
Node* prev = pos._node->_prev;
Node* next = pos._node;

Node* node = new Node(move(x));

node->_prev = prev;
node->_next = next;
prev->_next = node;
next->_prev = node;
_size++;

}
//....
ListNode(T&& x ) :
_next(nullptr),
_prev(nullptr),
_data(move(x))
{}

这样经过每一层的move保证了每次传递的都是右值：
在这里插入图片描述
我们就得到了想要的结果！！！

PS:对于内置类型或者Data来中，左值和右值是没有区别的，他们不会涉及到深拷贝的问题！使用涉及深拷贝的自定义类型才会涉及移动构造和移动赋值！

5 万能引用和完美转发

这里在介绍一个新语法：完美转发。它也可以上述做到move的效果，甚至更好！我们最好是使用完美转发！

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(T&& t)被叫做万能引用（引用折叠），虽然看上去是一个右值引用，但是他可以随机应变：传左值就是左值引用，穿右值就是右值引用。我们验证一下
在这里插入图片描述
可以看到，不是对应匹配的。因为还是那个原因：左值引用和右值引用都是左值！！！而引用折叠虽然会帮助我们实例化出：

void PerfectForward(int&& t)
{
Fun((int&&)t);
}
void PerfectForward(int& t)
{
Fun((int&)t);
}
void PerfectForward(const int&& t)
{
Fun((const int&&)t);
}
void PerfectForward(const int& t)
{
Fun((const int&)t);
}

但是由于右值引用是左值，所以根本调用不到右值版本！！！
所以这里如果使用move，行不行呢？我们试试：
在这里插入图片描述

move也无法解决这个问题，因为加上move之后，所以实例化的函数也都带有了func(move(t)),所有的都变成了右值，而我们想要的是该左值就是左值，该右值就是右值，所以就有了完美转发 — std::forward<T>(t)

template<typename T>
void PerfectForward(T&& t)
{
func(forward<T>(t));
}

完美解决：
在这里插入图片描述
完美转发就做到了：**完美转发在传参的过程中保留对象原生类型属性!**完美转发是在函数模版里面帮助辅助传参的！

实参传左值，就推导成左值引用
实参传右值，就推导成右值引用

完美转发本质上类似进行了一次强转！可以简单的这样理解：

template<typename T>
void PerfectForward(T&& t)
{
func((T&&)t);
}

上面的list也可以将move该成完美转发了！

Thanks♪(･ω･)ﾉ谢谢阅读！！！

下一篇文章见！！！

原文地址：https://blog.csdn.net/JLX_1/article/details/140484270

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：结合Redis解决接口幂等性问题
下一篇：如何获得Cesium的TileSet并设置本地服务器的Url

学生公寓管理系统
由于某些特殊原因，需要对学生当前入住的床位进行修改时，使用此功能。新生开学后，宿管管理可以先根据学生所在系查询该专业预定的宿舍和具体的床位入住状态信息，为该学生分配一个空闲状态的床位，并修改当前床位状
阅读更多2024-11-15
Windows上安装RabbitMQ 4.0.3教程
通过上述步骤，你应该已经成功在Windows上安装了RabbitMQ 4.0.3，并启用了管理插件。现在，你可以开始使用RabbitMQ来构建你的分布式系统了。希望这篇教程对你有所帮助，如果有任何问题
阅读更多2024-11-15
【蓝桥等考C++真题】蓝桥杯等级考试C++组第13级L13真题原题(含答案)-成绩排序
C++L13 成绩排序(50 分)
阅读更多2024-11-15
Web入门
HTTP（HyperText Transfer Protocol，超文本传输协议）是一种应用层协议。主要用于在Web浏览器和服务器之间传输数据。基于TCP协议：面向连接，确保了数据传输的可靠性和顺序。
阅读更多2024-11-15
Android 最新的AndroidStudio引入依赖失败如何解决？如:Failed to resolve:xxxx
在引入依赖时报错：Failed to resolve: xxx.xxxx:1.1.0。
阅读更多2024-11-15
力扣113：路径总和II
力扣113：路径总和II。C语言
阅读更多2024-11-15
【springboot使用sqlite数据库】Java后台同时使用mysql、sqlite
根据业务的需要，老版程序使用的数据库是sqlite，版本升级成前后台分离模式，因此需要兼容mysql与sqlite数据库同时使用。
阅读更多2024-11-15
力扣.15 三数之和 three-sum
这道题作为 leetcode 的第 15 道题，看起来似曾相识。大概思路可以有下面几种：暴力解法数组排序+二分Hash 优化双指针。
阅读更多2024-11-15
力扣第 53 题：最大子数组和
题目给定一个整数数组nums，目标是找到和最大的连续子数组（最少包含一个元素），并返回其和。例如，在数组中，和最大的子数组为，其和为6。
阅读更多2024-11-15
linux-缓冲区
调用系统调用接口是需要时间成本的，如果使用缓冲区，存储的字符串到一定长度再调用系统调用，能够有效减少调用系统调用的次数。这个缓冲区是语言设置的，缓冲区满足条件就用系统调用接口write将缓冲区的内容刷
阅读更多2024-11-15