目录
一 左值与右值
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是你命名的文件名字
经管编译器优化做的很好,但是这不是语言本身控制的,不同的编译器对上述代码的优化不同,很少像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引入右值引用的概念就是为了提高效率解决一些特殊场景下的问题,不管是右值引用还是左值引用都是再给一段空间取别名,只不过这段空间分为用户主动开辟与运行时临时变量两种。