【C++】右值引用及其相关功能
1 左值、右值
1.1 左值及左值引用
先看以下代码，但凡使用过 C++ 的人应该都很清楚，第三行代码是无法通过编译的，原因是非常量引用只能绑定在左值上。这里的左值表示有具体物理内存地址的值，即变量，因此使用符号 “&” 表示只能绑定在具体变量上的引用被称作左值引用。
int num_1 = 1；
int &num_2 = num_1;
int &num_3 = 1;
根据以下代码，在 C++11/C++0x 标准以前，如果需要将该左值引用绑定到一个常量上，通常的做法是使用常量引用以延长临时变量的生存期，这个操作在内存中同样也开辟了一块内存空间用于储存 1 和 get 函数的返回值。但遗憾的是，这些值都属于常量，无法被修改。
const int &num = 1;
const int &num = get(); // 设 get 函数的定义：int get() { return 1; }
1.2 右值及右值引用
在 C++11/C++0x 标准中提出了右值引用，与左值引用不同，右值引用绑定的对象是一个字面值、临时变量、将亡值（即右值）与常量引用类似，右值引用也能延长该临时值的生存期，但不同的是，所绑定的值是可以通过该右值引用修改的。可参考以下代码：
// 右值引用绑定在字面值 1 上，以延长该字面值 1 的生存期
int &&num = 1;
// 右值引用绑定在上临时值上
int &&num = get(); // 设 get 函数的定义：int get() { return 1; }
// 可随时对已被延长生存期的右值引用进行访问，右值引用变量在用于表达式时是左值
num = 2;
tips: 左值可以出现在赋值号 “=” 左边或者右边，而右值只可以出现在赋值号 “=” 右边。
拿一个不太恰当但容易理解的比喻：可以看做左值是个未爆炸的炸弹，右值是个即将爆炸的炸弹。
2 拷贝、移动构造函数
我们首先定义一个类，这个类封装了一个数组，并且提供有参、复制两个构造函数
class MyArray
{
int *_arr;
int _size;
public:
// 有参构造
explicit MyArray(int size) : _size(size)
{
cout << "parameter constructor" << endl;
_arr = new int[size];
}
// 复制构造
MyArray(const MyArray& my_array) : _size(my_array._size)
{
cout << "copy constructor" << endl;
_arr = new int[_size];
// 复制每一个元素
for (int i = 0; i < _size; i++)
_arr[i] = my_array._arr[i];
}
// 析构
~MyArray()
{
cout << "destructor" << endl;
if (_arr != nullptr)
{
delete _arr;
_arr = nullptr;
}
}
inline int &operator[](size_t __n) { return _arr[__n]; }
};
在 main 函数中写入
int main(int argc, char *argv[]) // line 1
{ // line 2
vector<MyArray> arrs; // line 3
arrs.reserve(5); // line 4
MyArray arr(1); // line 5
arrs.push_back(arr); // line 6
arrs.push_back(MyArray(1)); // line 7
return 0; // line 8
} // line 9
运行结果如下：
- 第一行是 line 5 运行的结果，调用有参构造
- 第二行是 line 6 运行的结果，将arr插入vector中，vector需要开辟一块新的空间来存储arr的内容，为复制构造
- 第三行是 line 7 中
MyArray(1)运行的结果，其创建了一个临时变量，调用有参构造 - 第四行是 line 7 中 push_back 运行的结果，将该临时变量复制到 vector 中，同样调用复制构造
- 第五行是临时变量在 line 7 运行结束之后销毁，调用析构函数所运行的结果
- 第六行、第七行是 vector 中的元素在return 0之后释放内存，调用析构函数
- 第八行是 line 5 的局部变量销毁
parameter constructor
copy constructor
parameter constructor
copy constructor
destructor
destructor
destructor
destructor
可以看到，对于临时变量的处理，传统的 C++ 显得十分笨拙，即创建一个新的空间，将该临时变量逐一复制到新空间，再销毁该临时变量，对于临时变量而言，如果能够将其数据所有权直接交给新空间，其物理内存地址不发生任何变动，那么将节省大量拷贝所浪费的时间。
其中，这个移交所有权的过程，在 C++ 中可以表示成将指针直接指向这个临时变量所在的地址，再让该临时变量“指向”空。这里的“指向”并不是C语言中指针指向某个地址的意思，而是该临时变量的变量名直接取址所指向的就是这块地址。这个操作可以看成该临时变量的内容直接移动到新空间中。
利用右值和右值引用的特点，可以加入一个新的构造函数，被称作移动构造函数。在上文 MyArray 类的代码中加入以下内容：
// move constructor
MyArray(MyArray &&my_array) : _size(my_array._size)
{
cout << "move constructor" << endl;
_arr = my_array._arr;
my_array._arr = nullptr;
}
运行结果如下，在运行中传入push_back的参数为一个临时变量，因此编译器优先匹配移动构造函数，因此第四行为移动构造函数的运行结果
parameter constructor
copy constructor
parameter constructor
move constructor
destructor
destructor
destructor
destructor
3 移动语义
在 C++11 中提供了一个函数：std::move() ，其作用就是将为了移交变量对于地址访问的所有权，也就是将左值变成右值，其做的转换等价于static_cast<T &&>，因此不会修改变量的值。现给出以下代码，同样以上文的 MyArray 类为例
int main(int argc, char *argv[])
{
MyArray arr1(1);
MyArray arr2(arr1);
MyArray arr3(move(arr1));
MyArray &&tmp = move(arr2);
MyArray arr4(tmp);
return 0;
}
运行结果如下：
-
首先，程序第一行调用有参构造函数。(结果第1行)
-
第二行利用现有的 arr1 构造 arr2，同时 arr1 不受影响，调用复制构造函数。(结果第2行)
-
然后程序调用了
std::move()，因此其得到了一个右值（临时值）尝试点炸弹 -
并且将其传给 arr3 调用移动构造，构造完成后 arr1 的数组内容将被释放。(结果第3行) 炸弹点着
-
接着调用
std::move()，得到了 arr2 的临时值，该临时值的生存期得以延长。尝试点炸弹 -
最后，访问 tmp 时，此处 tmp 已不再是右值，而是 arr2 的左值引用，因此调用复制构造函数。(结果第4行) 炸弹没点着
parameter constructor
copy constructor
move constructor
copy constructor
destructor
destructor
destructor
destructor
4 万能引用、完美转发
4.1 引用折叠机制
C++11开始便提供了引用折叠机制，具体示例代码如下
using lref = int &;
using rref = int &&;
int n = 10;
lref &r1 = n; // r1 的类型是 int&
lref &&r2 = n; // r2 的类型是 int&
rref &r3 = n; // r3 的类型是 int&
rref &&r4 = 1; // r4 的类型是 int&&
4.2 转发引用
转发引用（也称作万能引用）是一种特殊的引用，具有下列两种情形：
-
函数模板的函数形参，其被声明为同一函数模板的类型模板形参的无 cv 限定（
const以及volatile）的右值引用（T &&）template <typename T> int foo(T &&x) { return x; } template <typename T> int f(T &&x) { return foo(forward<T>(x)); } // x 是转发引用，从而能被转发 int main() { int i = 10; f(i); // 实参是左值，调用 f<int &>(int &), std::forward<int &>(x) 是左值 f(5); // 实参是右值，调用 f<int>(int &&), std::forward<int>(x) 是右值 } template <typename T> int g(const T &&x) { return x; } // x 不是转发引用：T 有 cv 限定 template <typename T> struct A { template <typename U> A(T &&x, U &&y, int *p); // x 不是转发引用：T 不是该构造函数的类型模板形参，但 y 是转发引用 }; -
auto &&，但当其从花括号包围的初始化器列表推导时除外auto &&vec = x_f(); // x_f() 可以是左值或右值，vec 是转发引用 auto i = std::begin(vec); // 也可以 (*i)++; // 也可以 x_g(std::forward<decltype(vec)>(vec)); // 转发，保持值类别 for (auto &&x : x_h()) { // x 是转发引用；这是使用范围 for 循环最安全的方式 } auto &&z = {1, 2, 3}; // 不是转发引用（初始化器列表的特殊情形）
总结：万能引用能保持函数实参的值类别，使得 std::forward 能用来完美转发实参。
参考文档
由于笔者水平有限，文中难免会有错误和疏漏之处，烦请各位读者评论指出！
440
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
