左值引用、右值引用、移动语义、完美转发，你知道的不知道的都在这里

众所周知C++11新增了右值引用，谈右值引用我们也可以扩展一些相关概念：

• 左值

• 右值

• 纯右值

• 将亡值

• 左值引用

• 右值引用

• 移动语义

• 完美转发

• 返回值优化

程序喵下面会一一介绍：

左值、右值

概念1：

左值：可以放到等号左边的东西叫左值。

右值：不可以放到等号左边的东西就叫右值。

概念2：

左值：可以取地址并且有名字的东西就是左值。

右值：不能取地址的没有名字的东西就是右值。

举例：

int a = b + c; 

a是左值，有变量名，可以取地址，也可以放到等号左边, 表达式b+c的返回值是右值，没有名字且不能取地址，&(b+c)不能通过编译，而且也不能放到等号左边。

int a = 4; // a是左值，4作为普通字面量是右值

左值一般有：

• 函数名和变量名

• 返回左值引用的函数调用

• 前置自增自减表达式++i、--i

• 由赋值表达式或赋值运算符连接的表达式(a=b, a += b等)

• 解引用表达式*p

• 字符串字面值"abcd"

纯右值、将亡值

纯右值和将亡值都属于右值。

纯右值

运算表达式产生的临时变量、不和对象关联的原始字面量、非引用返回的临时变量、lambda表达式等都是纯右值。

举例：

• 除字符串字面值外的字面值

• 返回非引用类型的函数调用

• 后置自增自减表达式i++、i--

• 算术表达式(a+b, a*b, a&&b, a==b等)

• 取地址表达式等(&a)

将亡值

将亡值是指C++11新增的和右值引用相关的表达式，通常指将要被移动的对象、T&&函数的返回值、std::move函数的返回值、转换为T&&类型转换函数的返回值，将亡值可以理解为即将要销毁的值，通过“盗取”其它变量内存空间方式获取的值，在确保其它变量不再被使用或者即将被销毁时，可以避免内存空间的释放和分配，延长变量值的生命周期，常用来完成移动构造或者移动赋值的特殊任务。

举例：

class A { xxx;};A a;auto c = std::move(a); // c是将亡值auto d = static_cast<A&&>(a); // d是将亡值

根据名字大概就可以猜到意思，左值引用就是对左值进行引用的类型，右值引用就是对右值进行引用的类型，他们都是引用，都是对象的一个别名，并不拥有所绑定对象的堆存，所以都必须立即初始化。

type &name = exp; // 左值引用type &&name = exp; // 右值引用

看代码：

int a = 5;int &b = a; // b是左值引用b = 4;int &c = 10; // error，10无法取地址，无法进行引用const int &d = 10; // ok，因为是常引用，引用常量数字，这个常量数字会存储在内存中，可以取地址

右值引用

如果使用右值引用，那表达式等号右边的值需要时右值，可以使用std::move函数强制把左值转换为右值。

int a = 4;int &&b = a; // error, a是左值int &&c = std::move(a); // ok

移动语义

谈移动语义前，我们首先需要了解深拷贝与浅拷贝的概念

深拷贝、浅拷贝

直接拿代码举例:

class A {public: A(int size) : size_(size) { data_ = new int[size]; } A(){} A(const A& a) { size_ = a.size_; data_ = a.data_; cout << "copy " << endl; } ~A() { delete[] data_; } int *data_; int size_;};int main() { A a(10); A b = a; cout << "b " << b.data_ << endl; cout << "a " << a.data_ << endl; return 0;}

上面代码中，两个输出的是相同的地址，a和b的data_指针指向了同一块内存，这就是浅拷贝，只是数据的简单赋值，那再析构时data_内存会被释放两次，导致程序出问题，这里正常会出现double free导致程序崩溃的，但是不知道为什么我自己测试程序却没有崩溃，能力有限，没搞明白，无论怎样，这样的程序肯定是有隐患的，如何消除这种隐患呢，可以使用如下深拷贝：

class A {public: A(int size) : size_(size) { data_ = new int[size]; } A(){} A(const A& a) { size_ = a.size_; data_ = new int[size_]; cout << "copy " << endl; } ~A() { delete[] data_; } int *data_; int size_;};int main() { A a(10); A b = a; cout << "b " << b.data_ << endl; cout << "a " << a.data_ << endl; return 0;}

聊完了深拷贝浅拷贝，可以聊聊移动语义啦：

移动语义，在程序喵看来可以理解为转移所有权，之前的拷贝是对于别人的资源，自己重新分配一块内存存储复制过来的资源，而对于移动语义，类似于转让或者资源窃取的意思，对于那块资源，转为自己所拥有，别人不再拥有也不会再使用，通过C++11新增的移动语义可以省去很多拷贝负担，怎么利用移动语义呢，是通过移动构造函数。

class A {public: A(int size) : size_(size) { data_ = new int[size]; } A(){} A(const A& a) { size_ = a.size_; data_ = new int[size_]; cout << "copy " << endl; } A(A&& a) { this->data_ = a.data_; a.data_ = nullptr; cout << "move " << endl; } ~A() { if (data_ != nullptr) { delete[] data_; } } int *data_; int size_;};int main() { A a(10); A b = a; A c = std::move(a); // 调用移动构造函数 return 0;}

std::vector<string> vecs;...std::vector<string> vecm = std::move(vecs); // 免去很多拷贝

完美转发

完美转发指可以写一个接受任意实参的函数模板，并转发到其它函数，目标函数会收到与转发函数完全相同的实参，转发函数实参是左值那目标函数实参也是左值，转发函数实参是右值那目标函数实参也是右值。那如何实现完美转发呢，答案是使用std::forward()。

void PrintV(int &t) { cout << "lvalue" << endl;}
void PrintV(int &&t) { cout << "rvalue" << endl;}
template<typename T>void Test(T &&t) { PrintV(t); PrintV(std::forward<T>(t));
 PrintV(std::move(t));}
int main() { Test(1); // lvalue rvalue rvalue int a = 1; Test(a); // lvalue lvalue rvalue Test(std::forward<int>(a)); // lvalue rvalue rvalue Test(std::forward<int&>(a)); // lvalue lvalue rvalue Test(std::forward<int&&>(a)); // lvalue rvalue rvalue return 0;}

分析

• Test(1)：1是右值，模板中T &&t这种为万能引用，右值1传到Test函数中变成了右值引用，但是调用PrintV()时候，t变成了左值，因为它变成了一个拥有名字的变量，所以打印lvalue，而PrintV(std::forward<T>(t))时候，会进行完美转发，按照原来的类型转发，所以打印rvalue，PrintV(std::move(t))毫无疑问会打印rvalue。

• Test(a)：a是左值，模板中T &&这种为万能引用，左值a传到Test函数中变成了左值引用，所以有代码中打印。

• Test(std::forward<T>(a))：转发为左值还是右值，依赖于T，T是左值那就转发为左值，T是右值那就转发为右值。

返回值优化

返回值优化(RVO)是一种C++编译优化技术，当函数需要返回一个对象实例时候，就会创建一个临时对象并通过复制构造函数将目标对象复制到临时对象，这里有复制构造函数和析构函数会被多余的调用到，有代价，而通过返回值优化，C++标准允许省略调用这些复制构造函数。

那什么时候编译器会进行返回值优化呢?

• return的值类型与函数的返回值类型相同

• return的是一个局部对象

看几个例子:

示例1：

std::vector<int> return_vector(void) { std::vector<int> tmp {1,2,3,4,5}; return tmp;}std::vector<int> &&rval_ref = return_vector();

const std::vector<int>& rval_ref = return_vector();

示例2：

std::vector<int>&& return_vector(void) { std::vector<int> tmp {1,2,3,4,5}; return std::move(tmp);}
std::vector<int> &&rval_ref = return_vector();

示例3：

std::vector<int> return_vector(void) { std::vector<int> tmp {1,2,3,4,5}; return std::move(tmp);}
std::vector<int> &&rval_ref = return_vector();

和示例1类似，std::move一个临时对象是没有必要的，也会忽略掉返回值优化。

最好的代码：

std::vector<int> return_vector(void) { std::vector<int> tmp {1,2,3,4,5}; return tmp;}
std::vector<int> rval_ref = return_vector();

这段代码会触发RVO，不拷贝也不移动，不生成临时对象。

参考资料

《Effective Modern C++》

《深入应用C++11：代码优化与工程级应用》

https://blog.csdn.net/u0105

https://www.jianshu.com/p/4538483a1d8a

https://www.cnblogs.com/xkfz007/articles/2506022.html

https://zhuanlan.zhihu.com/p/97128024

https://zh.cppreference.com/w/cpp/utility/forward

https://www.zhihu.com/question/43513150

https://stackoverflow.com/questions/4986673/c11-rvalues-and-move-semantics-confusion-return-statement?lq=1

一文让你搞懂设计模式

RAII妙用之ScopeExit

深入浅出虚拟内存

深入浅出虚拟内存（二）绘制虚拟内存排布图

深入浅出虚拟内存（三）堆内存分配及malloc实现原理

RAII妙用之计算函数耗时

一文吃透C++11中auto和decltype知识点

如果有任何问题或想法，可以 点此留言 ，我会尽快回复哒！欢迎小伙伴们踊跃留言，希望这里是大家交流互通的平台~