C++：左值/右值引用、移动语义/std::move、万能引用/完美转发std::forward 详解

`你能学到`

左值与右值
左值引用与右值引用基本用法与作用
拷贝构造函数与移动构造函数
移动语义与 std::move
万能引用与引用折叠
完美转发：std::forward

前言

本文代码片段中变量命名规则如下：

小写字母：一般类型的变量（非指针、非引用）
p：pointer，指针类型的变量（p1、p2…）
r：reference，引用类型的变量
- lr_*：比如 lr_a，a 的左值引用
- rr*：右值引用（rr1、rr2…）
上述均是非 const 变量，如果名称以 c 开头，说明该变量为 const
fun：function，函数名（fun1、fun2…）
大写字母：自定义类名

在说左值引用与右值引用之前，有必要先说说什么是左值，什么是右值：

c++ 中的左值与右值没有标准的定义，没必要死套公式、死扣细节，只需要理解即可。
如果你想要了解更多，可以通过关键字 c++ value categories 搜索相关资料。

1. 左值与右值

左值：lvalue
右值：rvalue

就它俩的英文缩写以及中文翻译，使得有一部分人将其解释为：

lvalue: left value
rvalue: right value

因此也诞生了对左值与右值的一种解释：

左值：能出现表达式左边
右值：不能出现在表达式左边

这种解释从某方面来说也可以是对的。下面我从另外一方面来解释什么是左值什么是右值：

1.1 左值

lvalue 是 loactor value 的缩写

左值指的是 存储在内存中，有明确内存地址的数据。因此在语法层面：

左值包含两部分信息:

内存地址：记录对象在内存中的位置
数据值：记录对象的值

所以它可以

出现在表达式的左边
出现在表达式的右边
取地址（&）

int a = 0;	// a 为左值，值为 1int b = a;	// 正确：a 能出现在右边
a = 1;	// 正确：a 能出现在左边
&a;	 // 正确：a 能取地址

【总结】 左值 可以取地址的、有名字的、非临时的，它是用户创建的，能通过作用域的规则知道它的生存周期。

1.2 右值

lvaue 是 read value 的缩写

右值指的是 可以提供数据值的数据。在语法层面：

右值仅包含数据值，因此它

只能出现在表达式左边
不可以取地址

int a = 0, b = 1;100;	// 100 是一个右值
100 = a;	// 错误：右值不能出现在左边
&100;	// 错误：右值不能取地址

【总结】 右值 不能取地址、没有名字、临时的，它的创建与销毁实际由编译器在幕后控制，对用户而言有用的信息仅仅是它的数据值。

【扩展】
在 c++ 中，右值实际分为两种：

纯右值 (prvalue)：

返回类型不是引用的一般函数的返回值

int fun() { int a = 1; return a; }
fun() = 1;	// 错误：fic() 返回值为纯右值

运算表达式的结果

int a = 0, b = 1;
a + b = 1;	// 错误：运算表达式 a + b 返回的是纯右值

原始字面量
lambda 表达式
取地址操作
… …

将亡值 (xvalue，就字面意思：即将死亡的临时对象)：
- 返回类型为右值引用的函数的返回值
- std::move 的返回值
- … …

总的来说，最直接地区分左值与右值的方法为：是否可以取地址。

2. 左值引用与右值引用

此部分讲解的主要内容在于：用左值或者右值给左值引用与右值引用进行赋值，不会讲解如果加了 const 修饰需要注意什么问题。如果你对后者感兴趣，看见作者的另外一篇文章：C++ const 关键字详解

无论是左值引用还是右值引用，在语法层面都是给对象起别名，与被绑定的对象共用同一块内存。在这里先记住一个结论：

左值引用视为左值
右值引用
有名称的视为左值
否则视为右值

2.1 左值引用

顾名思义，是对左值的引用，给左值起别名。

语法：类型 & 名称 = 左值

遵循以下规则：

非 const 的左值引用只能用左值来赋值。
const 的左值引用可以用右值来赋值。

看到这里你可能会疑惑：左值引用不是只针对左值吗，为什么还能用右值来赋值？别急，往后看。

// 以下变量都是左值
int  a = 0;
int* p = &a;
int& r = a;// 以下都是给左值起别名
int&  r_a = a;	
int*& r_p = p;	// 对 int* 的引用，类型解析从右到左/*** 直观上 r_r 是 r 的别名，* 但由于 r 是 a 的别名，* 因此 r_r 也可以看作 a 的别名 */
int& r_r = r;	// 特殊
int& r1 = 100;	// 错误：非 const 左值引用不能用右值初始化
const int& cr = 100;	// 正确：const 左值引用能用右值初始化

对于

const int& cr = 100;

这可能就会让人感到疑惑：

为什么左值引用 (const) 能引用右值？

先来看一个例子：

int fun(int& a) { }

如果我们尝试如下调用这个函数

fun(0);

会报错
在这里插入图片描述

这是因为 1 是一个右值，而非 const 的左值引用不能用右值初始化。在 c++11 以前不存在右值引用的概念，因此为了解决这一问题，引入了规则：

const 的左值引用既可以用左值赋值，也可以用右值赋值。

所以当参数类型为左值引用时，更建议使用 const 左值引用，也是出于这个考虑。
比如在老版本的 vector 模板的 push_back() 方法：

void push_back(const value_type& __x);vector<int> t;
int a = 1;// 以下均正确
t.push_back(a);
t.push_back(1);

2.2 右值引用

顾名思义，对右值的引用，给右值起别名。

语法：类型 && 名称 = 右值

遵循以下规则：

右值引用只能用右值初始化

int   a = 1, b = 1;
int*  p  = &a; 
int&  lr = a;
int&& rr = 100;
int&& fun() { return 0 }// 以下均是右值
100;
a + b;
&a;// 以下均正确
int&&   rr1 = 100;	
int&&   rr2 = a + b;
int* && rr3 = &a;	// 对 int* 指针的右值引用
int&&   rr4 = fun();	// fun() 的返回值为 int&&，无名称，视为右值// 以下均错误
int&& rr5 = a;	// a 是左值
int&& rr6 = p;	// p 是指针，为左值
int&& rr7 = lr;	// lr 为左值引用，视为左值
int&& rr8 = rr;	// rr 有名称右值引用，视为左值

从

// 以下均错误
int&& rr6 = lr;	// lr 为左值引用，为左值
int&& rr7 = rr;	// rr 是右值引用，为左值

也验证了之前所说的

左值引用视为左值
右值引用
有名称的视为左值
否则视为右值

既然有名称的右值引用是左值，它是用右值初始化的。也就是说

右值引用使得右值 “重获新生”，让此右值的生命周期与对应的右值引用的生命周期一样：只要该右值引用还活着，该右值也将一直存活下去。

基本语法搞定之后，那么你会好奇这么一个问题：

既然左值引用已经解决了用右值给左值引用初始化的问题，那为什么还要引入 右值引用 呢？

这是 为了性能考虑。

3. 移动语义与 std::move

move，可译为移动，但译为转移更为合适

3.1 移动语义

移动语义：转移对象的资源控制权

这么直接说定义比较难以理解，下面举个例子：

这例子源于某网站博主的文章 (文章结尾有指出本文的所有参考文章)

问题一：如何将大象放入冰箱？

答案是众所周知的。首先你需要有一台特殊的冰箱，这台冰箱是为了装下大象而制造的。你打开冰箱门，将大象放入冰箱，然后关上冰箱门。

问题二：如何将大象从一台冰箱转移到另一台冰箱？

普通解答：打开冰箱门，取出大象，关上冰箱门，打开另一台冰箱门，放进大象，关上冰箱门。
2B解答：在第二个冰箱中启动量子复制系统，克隆一只完全相同的大象，然后启动高能激光将第一个冰箱内的大象气化消失。

这里的 问题二 就比较好的说明了什么是移动语义。分析一下这个例子：
假设现在我们已经有了一个实体：大象A，需要通过 A 创建另外一个大象B，那么我们两套方案：

普通解答：将 A “移动” 到 B，即将 A 的资源转移给 B
2B解答：拷贝一份 A 的资源给 B，然后再将 A 的资源回收（即析构大象A）

即便你没有对底层有多了解，听了这个例子你也能得出：普通解答显然效率更高。

这两个解答就很好地对应了 c++ 的 2B解答——拷贝构造函数 与 普通解答——移动构造函数。

本文只讲解拷贝/移动构造函数，不讲解拷贝/移动赋值函数

不考虑其他的，移动构造函数的效率比拷贝构造函数要高。

因为拷贝构造函数会拷贝一份对象A 的资源，需要向操作系统申请资源（系统资源是十分昂贵的），再将资源赋给对象B，这就降低了性能；而移动构造函数则是直接将对象A 的资源转移给对象B，不存在申请资源操作。

既然移动构造函数的效率更高，那么为什么还保留拷贝构造函数？

需要注意，当调用了移动构造函数后，A 资源被转移了，那么 A 此时相当于是个 “废物” 了，如果你在之后仍然使用 A 对象，那么会导致未定义行为。

换句话说，移动构造函数相当于进行了废物利用：当明确对象A 在后续一定不会被使用时，那么它的资源可以转给其他需要此类型资源的对象，不需要重新申请资源，也不用释放资源。

废物也不是完全无用，因为它可以 回收利用 😐

但是如果对象A 你在后续仍然会使用，并且需要创建对象B，那么就应该调用拷贝构造函数。

从形式上看：

拷贝构造函数：参数为 const 的左值引用
移动构造函数：参数为右值引用

上面说了一堆理论，下面用代码来实现：

A 类如下

class A
{
public:A(int v) :_val{ new int(v) }{ }// * 拷贝构造函数A(const A& a)   // 使用 const，保证了原对象不会改变:_val{ new int(*(a._val)) } 	// new: 向操作系统申请了资源{ cout << "调用了拷贝构造函数" << endl; }// * 移动构造函数A(A&& a)    // 采用引用的方式，因为需要转移资源:_val{ a._val } 	// 转移资源{ /*** 由于 a 的资源被转移了，* 因此将 a 的资源 _val 指针指向 nullptr，* 避免之后误用 a*/a._val = nullptr; 	cout << "调用了移动移动函数" << endl;    }~A() {if (_val != nullptr) {delete _val;}} private:int* _val;
};

现在我们来使用 A 类

int main()
{A a(10);A b(a);	A c(std::move(a));	// move: 将 a 转为右值引用return 0;
}

执行输入为：
在这里插入图片描述

A 类的构造函数由多个（重载函数），但是编译器会利用指定的规则取匹配最合适的函数。
比如上述代码中：

A b(a);
a 的类型为 A，此时最合适的函数是 A(const A& a);
A c(std::move(a));
std::move(a) 的返回值为 A&&，即便 A(const A& a); 也能匹配，但是最合适的是 A(A&& a);

看完上面代码，相信让你比较疑惑的一点是 std::move：

3.2 std::move

源码如下：

template<typename _Tp>
constexpr typename std::remove_reference<_Tp>::type&&
move(_Tp&& __t) noexcept
{ return static_cast<typename std::remove_reference<_Tp>::type&&>(__t); 
}

可能有的地方你看不懂，但是不要紧，重点在 static_cast 关键字，它用于强制类型转换。

如果你对它的源码剖析感兴趣，可以见文章： C++11的右值引用、移动语义（std::move）和完美转发（std::forward）详解

也就是说，std::move 的作用 仅仅 是将一个传入的参数类型强制转换为右值引用，(而其返回值为右值引用，没有名称，因此被视为右值) ，我们可以用此函数来 辅助 实现移动语义。

比如上面代码中的 A c(std::move(c));
当我们确定 a 对象不在使用时，同时需要创建 c 对象，那么可以废物利用，将 c 转为右值，因此调用了 移动构造函数 将 a 的资源转移给 c。

【易错】

std::move 仅仅是做强制类型转换，没有实现资源转移的功能。

如果将 A 类的移动构造函数删除，那么执行 A c(std::move(a));，此时调用的是拷贝构造函数。
移动构造函数的 资源转移 功能依赖于它自己的内部实现，并不是说你调用了移动构造函数就实现了 资源转移 。

如果将 A 类的移动构造函数改为：
```
A(A&& a) { 	}
```
此时执行 A c(a);，即便调用的是拷贝构造函数，但是你并没有在内部实现如何转移资源。
资源转移并不包含 析构对象
在执行完 A c(std::move(a)); 后，除非调用析构函数，否则 a 对象仍然存在，只不过它的资源 (_val) 被转移给 c 对象了（由移动构造函数实现）。

4. 完美转发：std::forward

4.1 引入

在模板以及自动推导类型中，并不是说你指定了 && 它的类型就是右值引用：

模板：T&&
auto：auto&&

它们既可能是左值引用，也可能是右值引用，这种引用也被称为万能引用，T 的实际类型需要编译器进行推导。

【注意】

const auto && 或者 const T && 就是右值引用，不需要推导
只有 T 或者 auto 后紧跟 && 才可能是万能引用。
```
template <typename T>
fun(std::vector<T>>&& arg);
```
arg 不是万能引用，这是一个 vector<T> 类型的右值引用。
在上述提到的情况下，只有当类型需要推导时才是万能引用

对于下面的模板：
```
template <typename T>
fun(T&& arg);
```
- 对于函数调用 fun<int>(100); 来说 arg 不是万能引用
  
  因为此时已经明确指出 <int>，即明确告诉编译器 T 就是 int，所以不存在类型推导，所以 arg 不是万能引用
- 对于函数调用 fun(100); 来说，arg 是万能引用。
  
  因为没有指出 T 的类型，所以需要编译器自行推导，因此 arg 是万能引用。
当 arg 是万能引用时，那么 T 的类型是不确定的，需要编译器进行推导；
当 T 的类型被推导出来时，此时它的后面还有 &&，需要进行引用折叠，最终得到参数 arg 的实际类型。

万能引用推导规则 (以 T&& 为例，T 换为 auto 也是一样的)：

如果传入的参数是左值，那么 T 被推导为左值引用
如果传入的参数是右值，那么 T 被推导为非引用类型

引用折叠规则：

T& &、T&& &、T& && 被折叠为 T&
T&& && 被折叠为 T&&

下面看几个例子：

模板中的 const T&&

template <typename T>
void fun(const T&& t) { }	// t 就是 const 右值引用，不需要推导fun(100);    // 正确int&& rr = 100;	
fun(rr);	// 错误：rr 视为左值，不能给 右值引用初始化

模板中的 T&&

template <typename T>
void fun2(T&& t> { }	int   a  = 0;
int&  lr = a;
int&& rr = 0;// - 以下明确指出了 T 的类型，t 不是万能引用
//   但是存在 *引用折叠*
fun<int>  (10);	// t: int&&
fun<int&> (lr);	// t: int&  && -> int&
fun<int&&>(10);	// t: int&& && -> int&&// - 以下需要推导类型，t 是万能引用
fun(0);		// 0  为右值，所以 T = int  -> t: int&&
fun(a);		// a  为左值，所以 T = int& -> t: int&  && -> int&
fun(rr);	// rr 为左值，所以 T = int& -> t: int&  && -> int&// std::move返回值为右值，所以 T = int  -> t: int&& 
fun(std::move(rr));

auto 自动推导类型

int   a = 1;
int&  lr = a;
int&& rr = 100;
int&& fun() { return 0; }const auto&& rr1 = rr;	// 正确：rr1为右值引用
const auto&& rr2 = lr;	// 错误：rr2 是右值引用，不能用左值初始化// 以下变量类型均为右值引用
auto&& rr3 = 100;	// 100 为右值，所以 auto = int -> rr3: int&&
auto&& rr4 = fun();	// 同上// 以下变量类型均为左值引用	
auto&& lr1 = lr;	// lr 为左值，所以 auyo = int& -> lr1: int& && -> int&
auto&& lr2 = rr;  	// 同上

4.2 std::forward

std::forward 主要功能是：实现参数转递时，既能保留右值属性，也能保留左值属性。

这句话可能也很抽象，下面来分析一个例子：

#include <iostream>
using namespace std;void print(int&) { cout << "int&" << endl; }
void print(int&&) { cout << "int&&" << endl; }template <typename T>
void fun(T&& t)
{print(t);
}int main()
{int   a  = 0;int&  lr = a;int&& rr = 0;fun(a);fun(0);fun(lr);fun(rr);return 0;
}

程序如上，在模板函数 fun 中调用了 print 函数，并且 传递了参数 t。
下面分析程序的执行结果：

fun(a)
a 为左值，所以 T&& 被推导为 int&，那么 print 应输出 int&
fun(0)
0 为右值，所以 T&& 被推导为 int&&，此时你以为 print 应输出 int&&，然而结果并不是。前面我们提到过 有名称的右值引用被视为左值，因此虽然 fun 函数的参数 t 为 int&&，但是它被视为左值，所以 print 仍然输出 int&

说到这里就不在分析之后两个函数调用结果了，留给读者自行分析。

最后程序运行结果为：

在这里插入图片描述

分析完之后，我们发现了关键的问题所在：有名称的右值引用被视为左值。

如果我们想保留参数 t 的右值属性，也就是说如果传递给 fun 函数的参数 t 是右值，那么 fun内部调用其他函数时，所传递的参数 t 也要保留右值属性，即调用 print(int&&) 函数。

那么怎么实现呢？

有一个方案是 std::move，假设我们将 fun 函数修改为

template <typename T>
void fun(T&& t)
{print(std::move(t));
}

显然可以保留 t 的右值属性，但是这出现了一个问题：如果 t 是左值引用，那么 t 也被转为了右值。这不是我们想要的，我们更期望它既能保留右值参数的右值属性，也能左值参数的保留左值属性，这就是 std::forward 函数的功能：

template<typename _Tp>
constexpr _Tp&&
forward(typename std::remove_reference<_Tp>::type& __t) noexcept
{ 	return static_cast<_Tp&&>(__t); 
}template<typename _Tp>
constexpr _Tp&&
forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
{static_assert(!std::is_lvalue_reference<_Tp>::value,"std::forward must not be used to convert an rvalue to an lvalue");return static_cast<_Tp&&>(__t);
}

看源码可能比较费劲，下面我直接说结论：

如果你对其源码剖析感兴趣，见 C++11的右值引用、移动语义（std::move）和完美转发（std::forward）详解

第一个函数：

参数为左值引用（即 _Tp 为左值引用类型），返回类型通过引用折叠为左值引用。
第二个函数：
参数为右值引用（即 _Tp 为右值引用类型），返回类型通过引用折叠为右值引用。

因此，正确的做法是将 fun 函数改写为

template <typename T>
void fun(T&& t)
{	print(std::forward<T>(t));
}

下面来分析结果应该是什么。

源程序的函数调用顺序如下：

    fun(a);fun(0);fun(lr);fun(rr);

fun(a)

a 是左值，所以 T 为 int&，参数 t 为 int&，此时调用第一个 forward 函数，返回左值引用，所以 print 输出 int&
fun(0)

0 为右值，所以 T 为 int，参数 t 为 int&&，此时调用第二个 forward 函数，返回右值引用，所以 print 输出 int&&

其余留给读者去验证，尤其是最后一个

最终程序的执行结果为：
在这里插入图片描述

最后针对最终结果来总结以下：

fun(a)、fun(lr)、fun(rr) 的参数都是 左值，由于 fun 函数内部 std::forward 函数实现了完美转发：传递给 fun 函数的参数为左值，那么 std::forward 保留了它的左值属性，使得 fun 内部传递给 print 的参数仍然均有左值属性
fun(0) 的参数为右值，由于 fun 函数内部的 std::forward 函数实现了完美转发：传递给 fun 函数的参数为右值，那么 std::forward 保留了它的右值属性，使得 fun 内部传递给 print 的参数仍然具有右值属性。