左值、右值、左值引用和右值引用

文章目录
左值和右值
什么是左值和右值？
举例说明
程序分析
左值引用和右值引用
什么是左值引用和右值引用？
左值引用
右值引用 (important!!!）
左值和右值的转换
左值变右值
右值变左值
左值和右值
什么是左值和右值？
按照我们常规理解左值就是在等号左边的值，右值是等号右边的值。如果你要这么理解，你就会发现遇到++i或i++这一类的语句你就开始混乱了！

其实左值和右值是我们习惯性的叫法，他的全拼应该是：
左值是：locator value(可寻址的数据）
右值是：read value（不可寻址的数据或用来读的数据）

我们常规去理解，应该理解为：
在该程序语句之后能再找到该值，就是左值；否则就是右值。就是不可寻址！

举例说明
左值：

++x;
y*=33;
//这里面++x是直接对x自增，我们得到的值就是x的值，
//是可以后来直接使用x这个变量去使用这个值的。
1
2
3
4
右值：

x++;
y+3;
123；
//y+3这个值会被计算，但是没有被承接到，
//后来即便我们再用y+3去获得这个临时的值，大小是一样的，
//但不是我上次计算的那个值，我又经过了以此计算的到的。

//x++;这个从底层去分析：
//x++会产生一个临时变量，用来保存x+1的值，
//等到语句结束，将x+1赋值给x.
//但是语句没结束时，这个临时变量时在寄存器中保存的，一个计算结果的临时变量，
//此时是不可寻址的！！即右值。

1
2
3
4
5
6
7
8
9
10
11
12
13
程序分析
#include<iostream>
#include<string>

#define func(x) _func(x,"func("#x")")
using namespace std;

void _func(int &x,string str){ //左值值重载_func()
cout << str << "left value !"<<endl;
return ;
}

void _func(int &&x,string str){ //右值重载_func()
cout << str << "right value !"<<endl;
return ;
}
int main(){
int x = 3;
int y = 4;
func(123);
func(x++);
func(++x);
func(x*3);
func(x*=3);
func(y/4);
func(y/=4);
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
输出结果为：

func(123)right value !
func(x++)right value !
func(++x)left value !
func(x*3)right value !
func(x*=3)left value !
func(y/4)right value !
func(y/=4)left value !
1
2
3
4
5
6
7
左值引用和右值引用
什么是左值引用和右值引用？
什么是引用？
引用表示为符号“&”；
引用就是用另外的名称来索引到该变量。

左值引用
左值引用得到的就是还是一个左值。

#include<iostream>
using namespace std;
int main(){
int a = 10;
int &b = a;
cout << b << endl; //输出为10
b = 5;
cout << a << endl; //输出为5
cout << &a << " " << &b << endl; //a和b的地址相同。
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
分析：

其中a和b都是左值，他们都是一个变量，且都是表示相同地址上存放的某个int类型的数。
且此时输出a和b的地址是一样的。

右值引用 (important!!!）
右值引用的使用常常在自定义类中，可以查看该博文去理解。

右值引用操作符为 “&&”；
右值引用得到的是一个左值。
右值引用通常将一个临时变量拿过来用。
右值引用最主要的功能是解决的是自定义类重复构造冗余的问题。

下面三种情况就告诉你什么时右值引用？为什么要有右值引用？

未使用右值引用时且不去承接返回值：
//"test2.cpp"
#include<iostream>
using namespace std;

class A{
int x;
public:
A(int x = 0):x(x){
cout << this << ":default constructor"<<endl;
}
A(const A&a):x(a.x){
cout << this << ":copy constructor"<<endl;

}
A operator+(const A& a){
return A(x+a.x);
}
~A(){
cout << this << ":destructor"<<endl;
}
};

int main(){
A a(1),b(3);
a+b;

cout << "====================="<<endl;
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
通过关闭返回值优化g++ test2.cpp -fno-elide-constructor ，可以看到结果：

0x7fffbe1e127c:default constructor //A a(1)
0x7fffbe1e1280:default constructor //A b(3)
0x7fffbe1e1244:default constructor //A(a.x+b.x)
0x7fffbe1e1284:copy constructor //return A(a.x+b.x)->返回值会调用拷贝构造给承接a+b的变量A。代码中没有承接到a+b，会立马构析。
0x7fffbe1e1244:destructor
0x7fffbe1e1284:destructor
===================== //程序结束后构析
0x7fffbe1e1280:destructor
0x7fffbe1e127c:destructor
1
2
3
4
5
6
7
8
9
使用对象A直接去承接返回值
int main(){
A a(1),b(3);
A c = a+b; //此时用A类对象C承接返回值。

cout << "====================="<<endl;
return 0;
}
1
2
3
4
5
6
7
关闭返回值优化，得到结果：

0x7ffd08697558:default constructor
0x7ffd0869755c:default constructor
0x7ffd08697524:default constructor //A(a.x+b.x)
0x7ffd08697564:copy constructor //return A(a.x+b.x)的临时对象
0x7ffd08697524:destructor ~A(a.x+b.x)
0x7ffd08697560:copy constructor //A C = (return A(a.x+b.x)) 拷贝构造
0x7ffd08697564:destructor
=====================
0x7ffd08697560:destructor
0x7ffd0869755c:destructor
0x7ffd08697558:destructor
//可以看到产生大量的拷贝构造，临时变量我没有救火，卫视拷贝了一个拿来用。
1
2
3
4
5
6
7
8
9
10
11
12
使用右值引用且承接返回值
int main(){
A a(1),b(3);
A &&c = a+b; //右值引用

cout << "====================="<<endl;
return 0;
}
1
2
3
4
5
6
7
关闭返回值优化，得到结果：

0x7ffc22247b74:default constructor
0x7ffc22247b78:default constructor
0x7ffc22247b44:default constructor
0x7ffc22247b7c:copy constructor
0x7ffc22247b44:destructor
=====================
0x7ffc22247b7c:destructor
0x7ffc22247b78:destructor
0x7ffc22247b74:destructor
//可以发现return A(a.x+b.x)产生的临时对象直接被C用了，没产生多余的拷贝构造。
1
2
3
4
5
6
7
8
9
10
右值引用就是把右值变成左值，通常实在C++返回值上，对于自定子类的重复拷贝做了重要改善，大大提高了C++的效率。
右值引用的概念是C++中的重要概念！！！！。

左值和右值的转换
左值变右值
通过move(class value)函数
move()可以通过man手册查看。

通过通用转换 forward<B&&>
通过引用const &
变成只读，也是不能放在等号左边

右值变左值
通过右值引用&&

通过通用转换 forward<B&>
————————————————
版权声明：本文为CSDN博主「四库全书的酷」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_46535567/article/details/124568380