【C++11】右值引用 + 移动语义 + 完美转发（重点）

👦个人主页：@Weraphael
✍🏻作者简介：目前学习C++和算法
✈️专栏：C++航路
🐋 希望大家多多支持，咱一起进步！😁
如果文章对你有帮助的话
欢迎 评论💬 点赞👍🏻 收藏 📂 加关注✨

前言：STL中一些变化

• 新容器

在C++11中新增了以下几个容器（用橘色圈起来）：

实际上最有用的是哈希系列unordered_map和unordered_set。

剩下的容器array和forward_list非常鸡肋，实际上很少使用。

• array容器

文档介绍：点击跳转

在C++11标准中，引入了一个容器array，它的底层使用了非类型模板参数，是一个真正意义上的泛型数组（定长数组），这个是用来对标C语言传统数组的。

以下是array容器的基本用法：

看完以上接口，array支持的，数组也都是支持的。那么它们有什么区别呢？

• 相同点：array也并没有进行初始化。

• 要说有区别的话：array对于越界读、写检查更为严格；传统数组越界读写，不会发生报错

【吐槽】虽然对越界行为检查严格 ，但在实际开发中，很少使用array容器，因为它对标传统数组，连初始化都没有，并且大小也是固定的，因此不够灵活。

相比之下，vector也是类似于数组的容器，它允许动态改变大小、对于越界读和写检查也一样严格。因此，在功能和实用性上可以全面碾压array，因此可以说array是一个鸡肋的容器。

• forward_list容器

文档介绍：点击跳转

以下是forward_list的常见接口：

forward_list翻译过来就是单链表，因此一个结点只存值和指向下一个结点的指针。算了，直接开始喷（吐槽）吧。首先先说结论：forward_list还是一个非常鸡肋的容器。

• 从以上接口可以看出，它只支持头删pop_front和头插push_front。为什么不支持尾删和尾插呢？因为它效率低啊！尾插需要找到尾结点、尾删需要找到尾节点的前一个结点，这些操作都要从头部开始向后遍历，时间复杂度铁铁的O(N)
• 另外，forward_list还不提供size()接口

如果要说forward_list有优势，那就是内存占用更小（每个结点节省了一个前驱指针），但是它还是比较鸡肋，因此在实际中使用list会更多一点。

• 容器中的一些新方法

如果我们再细细去看会发现基本每个容器中都增加了一些C++11的方法，但是其实很多都是用得比较少的。

比如cbegin和cend

这玩意其实也很鸡肋，因为普通版的begin和end都已经重载了const版本。对于C++开发人员还是区分得开的。

有坏当然也有好的方面，比如：

1. 所有容器均重载了initializer_list<T>，使容器初始化更加方便。
2. 所有容器均支持移动构造和移动赋值，可以极大提高效率（本篇重点）

3. 所有容器均支持右值引用相关插入接口，同样可以提高效率（本篇重点）

一、如何判断左值和右值

要想搞懂左值引用和右值引用，首先要得明白什么是左值和右值。很多人认为在赋值符号左边的就是左值，在赋值符号右边的就是右值。 这其实并不完全正确，比如：

int main()
{int a = 1; // a是左值int b = a; // a又变成右值？
}

所以，以上变量a到底是左值还是右值？（答案是：左值）

• 交给大家简单粗暴的判断左值的方法：可以取地址就是左值。

举个例子，以下是常见的左值：

• 如何判断右值？

右值通常被认为是临时的、一次性的值或者是将亡值。 右值可以出现在赋值符号的右边，但是绝不能出现出现在赋值符号的左边。就这么说吧，只要 不能取地址的就是右值。常见的右值有：字面常量、表达式返回值，函数返回值（临时对象返回）等。

二、左值引用和右值引用

大家只要记住一句话，不管是什么引用，都是取别名。左值引用就是对左值取别名，右值引用就是对右值取别名。

• 首先先来看看左值引用的例子

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

由上可以看出，左值引用就是C++刚入门学的那个引用，唯一有区别的还是右值引用。

• 用两个&&表示右值引用。

double Min(double x, double y)
{return x > y ? y : x;
}int main()
{// 以下几个都是常见的右值10;1.1 + 2.2;Min(1.1, 2.2);// 以下几个都是对右值的右值引用int&& rr1 = 10;double&& rr2 = 1 + 2;double&& rr3 = Min(1, 2);return 0;
}

三、左值引用 vs 右值引用

• 问题1：左值引用能否给右值取别名？

正常来说是不行的，但由于 右值都具有常属性，因此用const引用即可。

• 问题2：右值引用能否引用左值？

编译器已经给出很明确的报错信息了：无法将右值引用绑定到左值。

但右值引用可以引用move以后的左值。点击跳转

既然左值引用即可以引用左值，也能引用右值。那么以下情景是否构造函数重载？是否存在调用歧义呢？

答案是当然构成重载，编译器会选择最匹配的参数调用。

四、move函数

• 虽然右值引用不能直接引用左值，但是可以通过调用一个名为move函数来获得绑定到左值上的右值引用。

• move的主要作用是显式地标识对象为右值，以便编译器能够选择调用移动语义相关的操作，而不是进行拷贝操作。

int a = 0;
int&& rr = move(a);

可以这么理解：当右值引用 引用右值时，则是先将引用的对象的临时资源 “转移” 到特定位置（不会发生拷贝），然后指向该位置中的资源，此时可以对右值进行修改操作。

另外，虽然右值引用引用的是右值，但右值引用本身是可以取地址的

除此之外，语法还支持给右值引用加const，这样做的含义是 不能修改右值引用后的值。

但我们一般建议不要用const右值引用，因为使用右值引用就是为了“转移”资源，加了const还不如直接改用const左值引用。

注意：不要轻易使用move函数，左值中的资源可能会被转走。如果此时我们直接将左值move后构造一个新对象，会导致原本左值中的资源丢失。

五、 右值引用使用场景

5.1 场景一：移动语义

前面我们可以看到左值引用既可以引用左值也可以通过const引用引用右值，那为什么C++11还要提出右值引用呢？

既然提出了就一定是为了解决左值引用存在的缺陷，那么我们可以通过分析左值引用的使用场景及核心价值来推断。

【左值引用】

• 使用场景：1. 做输出型参数（形参的改变影响实参）。 2. 做返回值。
• 核心价值：减少拷贝，提高效率。

我们知道，左值引用做返回值是有一定的缺陷的！如果是左值引用做返回值，出了作用域，对象不能被销毁；如果出了作用域，对象被销毁，那么就不能使用左值引用做返回值。
（不知道为什么可以看看这篇博客：点击跳转）

string func()
{string str("hello world");return str;
}int main()
{string s = func();cout << s << endl;return 0;
}

str是局部对象，出了func函数作用域，对象销毁，那么就不能用左值引用返回，那么按照惯例只能使用传值返回。而 传值返回是有代价的，对于较大的对象（如大型结构体、类对象等），可能会导致较大的性能开销，因为它需要在内存中复制整个对象的内容。

接下来可以简单的来验证一下，下面是简单模拟实现的string类，为了更好的观察是否发生了深拷贝行为，在 拷贝构造函数中加入了对应的打印语句。

• string.h

#pragma once
#include <iostream>
#include <assert.h>
namespace wj
{class string{public:typedef char* iterator;iterator begin(){return _str;}iterator end(){return _str + _size;}string(const char* str = ""):_size(strlen(str)), _capacity(_size){_str = new char[_capacity + 1];strcpy(_str, str);}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};
}

• Test.cpp

以上代码本来应该是两次拷贝构造，但对于一行的两次拷贝构造，新一点的编译器会优化成一次拷贝构造。虽然优化成一次拷贝构造，但是还是需要拷贝整个对象的内容，但是有很大的消耗。

因此，C++11中允许使用移动语义之移动构造解决上述问题：在wj::string中增加移动构造，移动构造本质是窃取别人的资源来构造自己，占位已有，那么就不用做深拷贝了（提高性能），所以它叫做移动构造。

• 移动构造

string(string&& s):_str(nullptr)
{cout << "string(string&& s) -- 移动构造" << endl;swap(s);
}

接下来再来看看结果：

那么问题来了，对象str是一个左值啊，它是怎么调用移动构造函数的？

这其实是编译器的优化！当Myfunc函数返回一个wj::string对象时，编译器会在其内部将str视为右值，并使用移动构造函数来将其内容转移到 s 中。这样做可以避免不必要的拷贝操作，提高了程序的性能

接下来再来看，如果两次的拷贝构造不再同一行，编译器就不能实现优化，那么就是实打实的两次拷贝构造，那么这个消耗是巨大的。（在此之前我屏蔽了移动构造）

第三次打印的结果是无法避免的，因为在调用operator=会重新开辟空间来深拷贝对象的资源。

因此，C++11同时也引入了移动语义之移动赋值，用于在对象之间实现资源的高效转移。移动赋值运算符允许将一个对象的资源从另一个对象转移到自身，而不是通过拷贝构造或拷贝赋值运算符来进行资源的复制。

• 移动赋值

// 赋值重载
string& operator=(string&& s)
{cout << "string& operator=(string& s) -- 移动赋值" << endl;swap(s);return *this;
}

接下来再将移动拷贝的代码取消注释，然后再来看看打印结果

综上，移动语义（移动构造 + 移动赋值）弥补了自定义类型中深拷贝的类，必须传值返回的场景。避免不必要的资源复制，提高了程序的性能和效率。

5.2 场景二：STL容器插入接口函数

C++11标准出来之后，STL中的容器除了增加移动构造和移动赋值之外，STL容器插入接口函数也增加了右值引用版本。

那么右值引用版本插入函数的意义是什么呢？

如果list容器当中存储的是string对象，那么在调用push_back向list容器中插入元素时，可能会有如下几种插入方式：

• 对于第一个一定会完成深拷贝，因为s对象是左值，那么lt对象在调用push_back一定会选择最合适的，也就是void push_back (const value_type& val);

• 剩下的一定会调用void push_back (value_type&& val);。字符串字面量（如 "11111111111111"）时，它会调用右值引用版本的 push_back。这是因为字符串字面量是临时对象，是右值，而 push_back 函数的右值引用版本接受右值参数（提高效率）。

5.3 场景三：完美转发

5.3.1 万能引用

在模板中的&&不代表右值引用，而是万能引用，其既能接收任意类型的左值和右值。

• 如果传入的实参是左值，那么编译器就会将模板实例化为左值引用，也称做引用折叠。
• 如果传入的实参是右值，那么编译器就会将模板实例化为右值引用。

【基本语法】

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

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

我们来判断是否真的很“万能”

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

【程序结果】

输出的结果好像和我们一开始说的不太一样，最终都匹配到了左值引用版本的Func函数。接下来可以分析为什么？

首先先看第一次调用PerfectForward(10)，由于PerfectForward函数的参数类型是万能引用，因此在编译器眼中其实是如下这样的：

// 实参10是int类型，那么对应的T应该实例化为int
// 并且实参10是右值，编译器就会将模板实例化为右值引用
template<typename int>
void PerfectForward(int&& t)
{Fun(t);
}int main()
{PerfectForward(10); // 右值return 0;
}

这下好像有点眉目了，实参（右值）10传递给形参t，然后再通过t去调用Func函数，而t虽然引用右值，但是它本身是可以被取到地址，并且可以被修改，所以在PerfectForward函数中调用Func函数时会将t识别成左值。

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

5.3.2 完美转发保持值的属性

要想在参数传递过程中保持其原有的属性，需要在传参时调用forward函数。基本语法如下：

template<class T>
void PerfectForward(T&& t)
{Func(forward<T>(t));
}

经过完美转发后，调用PerfectForward函数时传入的是右值就会匹配到右值引用版本的Func函数，传入的是const右值就会匹配到const右值引用版本的Func函数，这就是完美转发的价值。

六、相关代码

Gitee仓库链接：点击跳转