C++ 左值引用与右值引用超详解

一左值与右值

1.左值

2.右值

3.总结

二左值引用与右值引用

1.左值引用

2.右值引用

3.总结与探究

3.1右值引用可以修改么？取地址么？

3.2左值引用与右值引用转化

左值引用引用右值

右值引用引用左值

3.3左值引用与右值引用相同之处

3.4左值引用与右值引用不同之处

三引用用处

1.左值引用

2.右值引用

2.1移动构造

2.2移动赋值

2.3完美转发

3.总结

一左值与右值

1.左值

左值是一个表示数据的表达式(如变量名或解引用的指针)，我们可以获取它的地址并且可以对它赋值，左值可以出现赋值符号的左边，右值不能出现在赋值符号左边。定义时const修饰符后的左值，不能给他赋值，但是可以取它的地址。我们可以修改左值，但不可以修改右值。左值引用就是给左值的引用，给左值取别名。

如下都c,p,b为左值。

int c = 0;
const int b = 2;
int* p = nullptr;

2.右值

右值也是一个表示数据的表达式，如：字面常量、表达式返回值，函数返回值等等，右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能取地址，我们也不能修改右值。右值引用就是对右值的引用，给右值取别名。

以下都为右值

int fun()
{return 1;
}
void test()
{int a = 1, b = 2;//右值10;a + b;fun();
}

如下图，将右值放在=左边就会报错，对其取地址也会报错

3.总结

左值一般为我们自己定义的变量，在定义时开辟了内存，我们可以对这块内存赋值，修改内存中的值，如果有const也仅从语法层面上不允许修改，这块内存在其生命周期结束的时候销毁。

右值一般为临时变量，是程序运行时产生的中间产物，他不是我们用户自己定义开辟空间的，是由编译器帮我们开辟空间，并且在用完就立即销毁。右值的生命周期一般只在当前语句，当我们要对右值进行赋值时，他已经释放空间了，此时我们再进行访问就是野访问，（与野指针一样造成内存问题），所以我们不能对右值进行修改，编译器强制语法检查，遇到修改操作就报错。

右值中特殊的就是字面常量，他们存储在内存的常量区，内存为只读属性，不可以修改，不可以取地址，他们的生命周期与程序的生命周期一样，不会用完即销。

分辨左右值最常用方法就是判断他是否可以取地址。如果不可以就为右值。

二左值引用与右值引用

1.左值引用

左值引用就是给左值的引用，给左值取别名。

int c = 0;
const int b = 2;
int* p = nullptr;//左值引用
int& lc = c;
const int& lb = b;
int*& lp = p;

在int& lc = c;语句后，lc与c使用的是同一块空间，lc与c完全等效，一荣俱荣，一损俱损。

2.右值引用

右值引用就是对右值的引用，给右值取别名。他的语法与左值引用十分相似，右值引用语法为对应类型加上两个& 。

int fun()
{return 1;
}
void test()
{int a = 1, b = 2;//右值引用int && r1=10;int && r2=(a + b);int && r3=fun();
}

如果改为左值引用就会报错，如下图。

3.总结与探究

首先明确一点就是不管是左值引用还是右值引用，都是给一段数据取别名。对于左值引用而言，他与绑定的变量共用同一块空间，是之前我们定义该变量（左值）开辟的空间，没有再开辟出新内存。

对于右值引用而言，他也没有开辟内存，他绑定的一块空间是编译器运行时为右值自动开辟的空间，没有再开辟出新内存。

在这里有个矛盾？右值引用引用干了什么？如果按照编译器对于普通右值的处理，当前语句结束就销毁，那么右值引用指向的空间就是野空间（参照指针叫法），我们对右值引用修改就会造成内存泄漏等重大内存问题，那么这样不就是脱裤子放屁了么！

显然右值引用语法规定不是这样的，（以该句为例int && r3=fun();）当我们用r3引用fun（）这个右值的时候，这块空间原本是由编译器释放销毁的，但被人为的抢走释放权限，加上右值引用这句话，就相当于说明我认为这块空间还有利用的价值，你编译器先别着急释放，交给我来释放，这里水很深，交给我来把握。我们就拥有了这块空间的生杀大权，编译器就不会立即释放该内存。

3.1右值引用可以修改么？取地址么？

右值是一定不可以修改和取地址的，那么右值引用可以么？注意右值引用和右值是两个东西，只有左值引用和左值才一样，左值引用可以修改和取地址。

实践是检验真理的唯一标准，上代码。

int main()
{//右值引用int&& r1 = 10;cout << r1 << endl;cout << (void *) & r1 << endl;r1 = 20;cout << r1 << endl;return 0;
}

运行结果如下。右值引用时可以修改的，也可以取地址。

其实当执行完int&& r1 = 10;语句后他就与int c = 10;int& r1 = c;这两句的效果一样，到这里可能很多人被饶了进去，我们来捋一捋。

为什么右值不可以修改？（取地址实际上也是为了后面修改操作）因为右值当当前语句结束就销毁，后面语句再访问就是访问野空间。

为什么右值引用可以修改？我们从编译器手中拿走了右值销毁的权利，“右值”在引用后依旧存在，可以进行正常的访问修改操作。

左值引用和左值使用的都是用户自定义开辟的空间，所以左值支持修改。

我们可以通过一些汇编了解左右值引用

通过上图我们可以更好的理解这句话。不管是左值引用还是右值引用，都是给一段数据取别名。

3.2左值引用与右值引用转化

左值引用引用右值

首先如下代码是正常的定义右值引用，是没有任何问题的，那么我们可以使用左值引用么？

int&& ra = 10;

如下代码，直接使用左值是错误的，编译器报错。通过上述的汇编图我们知道左值引用与右值引用最后都转化为指针，那么左值引用与右值引用的语法就是为了通过编译器的语法检测，编译器检测右值不支持修改操作，但一般的左值引用支持修改，我们就可以加上const，禁止修改，骗过编译器检测。

int& la = 10;

如下图。直接使用左值引用是会报错的，加上const修饰就可以通过编译器语法检查。

将上述右值引用修改便可以通过编译

int fun()
{return 1;
}
void test()
{int a = 1, b = 2;//左值引用const int& r1 = 10;const int& r2 = (a + b);const int& r3 = fun();
}

右值引用引用左值

首先如下代码是正常的定义左值引用，是没有任何问题的，那么我们可以使用右值引用么？

int c = 0;
//左值引用
int& lc = c;

直接写如上图是肯定不可以的，编译器会进行类型检查，类型不匹配就报错。我们就可以通过强制类型转换骗过编译器。如下图，此时就不会有报错了。

如下都是可以通过编译的。

int c = 0;
const int b = 2;
int* p = nullptr;//右值引用
int&& lc = (int&&)c;
const int&& lb = (const int&&)b;
int*&& lp = (int*&&)p;

并且在右值引用后，lc与c用的是同一块空间，此时仿佛lc是左值引用一样。我们可以通过如下代码检测。

int main()
{int c = 0;//右值引用int&& lc = (int&&)c;cout << c <<" " << lc << endl;c = 1;cout << c <<" " << lc << endl;lc = 112;cout << c <<" " << lc << endl;return 0;
}

通过上述代码验证，我们就可以断定他们用的是同一块空间。

看到大家这都会十分疑惑，C++11更新右值引用干什么？绕来绕去，闲的没事么？其实不尽然，C++这样设计是为了提高效率，减少深拷贝的消耗，在第三大模块再细谈。

3.3左值引用与右值引用相同之处

1.都是引用，都是再给一段空间取别名

2.除了const修饰外，左值引用与右值引用都可以修改。

3.底层都是指针，语法层面不同罢了

3.4左值引用与右值引用不同之处

1.左值引用引用左值，左值可以修改；右值引用引用右值，右值不可以修改

2.左值是由用户自定义变量组成，右值一般为编译器运行时定义临时变量。

三引用用处

1.左值引用

通过上图的汇编代码，我们可以知道引用有和指针同等的效率，那么在函数设计传递参数的时候，我们就可以传递引用来代替指针，如下代码。

void Print1(vector<int> & t)
{}
void Print2(vector<int>* pt)
{}int main()
{vector<int> t1(10);Print1(t1);Print2(&t1);return 0;
}

用左值引用代替指针后，不仅用起来更方便，在传参时不需要加上&，使用时不用加上*，并且引用比指针更加的安全。如果在 Print2中修改pt的值，就会造成野指针问题，而vector<int> & t就相对而言更加的安全了。

2.右值引用

2.1移动构造

为了下面举例现象明显，可以简单实现string类

#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<assert.h>
using namespace std;//MyString
namespace MS
{class string{public:const  size_t npos=-1;//构造函数string(){cout << "string():" << endl;_size = 0;_capacity = 0;_str = new char[1] {'\0' };}string(const char* str){cout << "string(const char* str):" << endl;int sz = strlen(str);_str = new char[sz + 1];strcpy(_str, str);_size = sz;_capacity = sz;}string(const string& s){cout << "string(const string& s):" << endl;_str = new char[s._size + 1];strcpy(_str, s._str);_size = s._size;_capacity = s._capacity;}//析构函数~string(){delete[] _str;_str = nullptr;}string& operator=(const string& s){cout << "operator=(const string& s):" << endl;if (this != &s){delete[] _str;_str = new char[s._size + 1];strcpy(_str, s._str);_size = s._size;_capacity = s._capacity;}return *this;}string& operator+= (const string& str){int len = str._size;reserve(_size + len);strcpy(_str + _size, str.c_str());_size += len;return *this;}const char* c_str()const{return _str;}string& operator+= (const char* s){int len = strlen(s);reserve(_size + len);strcpy(_str + _size, s);_size += len;return *this;}string& operator+= (char c){reserve(_size + 1);_str[_size] = c;_str[_size + 1] = '\0';_size++;return *this;}void reserve(size_t n){if (n <= _capacity)return;char* tmp = new char[n + 1];strcpy(tmp, _str);delete[]_str;_str = tmp;_capacity = n;}//容量size_t size()const{return _size;}size_t capacity()const{return _capacity;}void swap(string& str){std::swap(_str, str._str);std::swap(_size, str._size);std::swap(_capacity, str._capacity);}friend string to_string(int value);friend ostream& operator<< (ostream& os, string& str);private:int _size=0;int _capacity=0;char* _str=nullptr;};string to_string(int value){bool flag = true;if (value < 0){flag = false;value = 0 - value;}string str;int d = 0;while (value > 0){int x = value % 10;value /= 10;str += ('0' + x);d++;}if (flag == false){str += '-';}for (int i = 0; i < d / 2; i++)swap(str._str[i], str._str[str._size - i - 1]);return str;}ostream& operator<< (ostream& os, string& str){for (int i = 0; i < str.size(); i++){os << str._str[i];}return os;}
}

假如我们运行下述代码。

int main()
{MS::string s1 = MS::to_string(123);cout << s1<<endl;return 0;
}

MS::to_string(123)返回的是string类型对象，然后s1拷贝构造这个对象完成初始化。如下图

由上图可以知道我们为了初始化s2创建了两次str变量，一次是在to_string函数中，一次是为函数返回值创建，这是完全不优化的情况，事实上现在的编译器会有优化，可以将为返回值创建str改为直接创建s2，减少依次拷贝消耗，如下图。

上面这种还是比较可以理解的优化，但VS2022开的优化更大更叹为观止，即使上面优化后，我们任然要建立两次变量，但VS2022把s2与to_string中的str优化为一个变量，这样就只用建立一个变量如下图。

这里调用的是str的构造函数，VS将s2与str优化成一个变量，故只有一次构造函数。

VS2022的优化程度十分大，如果想运行完全不优化的编译器，可以在linux下添加额外指令运行，如下

命令为：其中a.cpp 为源文件名，-o 后面的aobj是你命名的文件名字

g++ -fno-elide-constructors Teacher.cpp -o aobj

经管编译器优化做的很好，但是这不是语言本身控制的，不同的编译器对上述代码的优化不同，很少像VS2022优化这么大，C++11就引入了右值引用的语法用来优化上述的代码。

回到最初的代码。MS::to_string(123);返回值按照我们之前讲的就是右值，那么我们就可以根据右值类型增加个构造函数。

int main()
{MS::string s1 = MS::to_string(123);cout << s1<<endl;return 0;
}

如下代码。我们就在构造函数中直接掠夺右值引用的资源，交换后就相当于初始化完了s2变量，我们称这种特殊的构造函数叫做移动构造。

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

加上移动构造后，上述代码运行结果如下。这看起来我们创建了两次string变量，实际上我们只消耗了创建一个str变量的时间，第二次创建只是交换资源，代价极小。这样不管编译器做不做优化，根据语法我们就可以优化上述的情况，提高效率。

2.2移动赋值

显然我们不只会有构造时候有右值，=赋值的时候也会出现右值，这样我们就可以像上面重载构造函数一样，重载赋值函数，提高效率。

int main()
{MS::string s2;s2 = MS::to_string(123);cout << s2;return 0;
}

上述代码运行结果如下

经过编译器的优化后，我们任然需要消耗创建两个个str变量的时间，此时就可以重载右值版本的赋值重载函数如下。

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

运行结果如下。这样看起来还是消耗创建两个个str变量的时间，但我们知道移动赋值只交换了资源，消耗极小。于是就相当于提高了效率。

2.3完美转发

首先了解一个std中函数move，他的作用是将参数类型强制转换为右值，不管参数是左值还是右值。

运行如下代码

int main()
{MS::string s1("1234");MS::string s2(s1);MS::string s3(move(s1));return 0;
}

如下分析

现有如下模板，C++11规定T&&可以接受右值引用也可以接受左值引用，也就是说t可以为右值也可以为左值。

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

如下代码是可以正常运行的。结果如下图。


template<typename T>
void PerfectForward(T&& t)
{cout << t << endl;
}int main()
{PerfectForward(10);           // 右值int a = 1;PerfectForward(a);            // 左值return 0;
}

经过之前我们看的汇编代码我们也可以更好的理解这种用法，不管左值引用还是右值引用最后都转化为指针处理，只要强制转换或者加上const就可以骗过编译器。

接着运行下述代码

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=1;PerfectForward(a);            // 左值PerfectForward(std::move(a)); // 右值const int b = 8;PerfectForward(b);      // const 左值PerfectForward(std::move(b)); // const 右值return 0;
}

运行结果如下。我们最后打印的都是左值，只是由于右值引用在绑定右值后就退化为左值引用，编译器将t都识别为左值引用。绑定后的右值引用和左值引用没什么区别，都可以赋值都可以取地址，编译器不会主动的区分他们。

为了解决上述的情况，就引入了完美转发概念，即在传递过程中保持引用的特性，即右值引用不退化。引入forward函数，如果为左值什么都不办，为退化后的右值，进行一次move

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

对于左值，模板相当于实例化出如下代码。

int a=1;
PerfectForward(a);            // 左值
void PerfectForward(T&& t)
{Fun((t));
}

对于右值，模板相当于实例化出如下代码。在传递中保持右值属性。

PerfectForward(std::move(a)); // 右值
void PerfectForward(T&& t)
{Fun(move(t));
}

加上这句代码后就可以正常运行，如下图

3.总结

C++11引入右值引用的概念就是为了提高效率解决一些特殊场景下的问题，不管是右值引用还是左值引用都是再给一段空间取别名，只不过这段空间分为用户主动开辟与运行时临时变量两种。