左值与右值

发表于 更新于 分类于

基本概念

左值：在内存中有可以访问的地址，对象是一个左值。

右值：不可以取地址，整数10是个右值。

引用：对象的别名，没有创建新的对象，仅仅给已经存在的对象赋予了一个新的名字。

  1. 引用是对象的别名，对于引用的一切操作都是对对象的操作；
  2. 引用自身从概念上没有大小（或者就是对象的大小）；但引用在传递或需要存储时，其传递或存储的大小为地址的大小。
  3. 引用必须初始化；
  4. 引用不可能重新绑定；
  5. 将指针所指向的对象绑定到一个引用时，需要确保指针非空。
  6. 任何引用类型的变量，都是左值。

四种类型引用：

|:—-|—-:|:—-:|
|类型|例子|备注|
|const lvalue refrence|Foo foo(10); const Foo& ref = foo;| |
|const rvalue refrence|const Foo& ref = Foo(10);| |
|non-const lvalue refrence|Foo foo(10); Foo& ref = foo;| |
|non-const rvalue refrence|Foo&& ref=Foo(10);|C++11才开始有|

move语义

C++11 之前，只有 copy 语意，这对于极度关注性能的语言而言是一个重大的缺失。

对move 语意的急迫需求，到了 C++11 终于被引入。其直接的驱动力很简单：在构造或者赋值时，如果等号右侧是一个中间临时对象，应直接将其占用的资源直接 move 过来（对方就没有了）。

但问题是，如何让一个构造函数，或者赋值操作重载函数能够识别出来这是一个临时变量？

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
/////////////hello.cpp/////////////////
#include <iostream>
using namespace std;
struct Foo
{
	Foo(){ cout << "Foo()" << endl; }
	Foo(const Foo&ref){ cout << "Foo(const Foo&)" << endl; } // copy ctor
	Foo(Foo&& ref){ cout << "Foo(Foo&&)" << endl; }          // move ctor
	Foo& operator=(const Foo& rhs){cout << "Foo& operator=(const Foo& rhs)" << endl; } // copy assignment
	Foo& operator=(Foo&& rhs){cout << "Foo& operator=(Foo&& rhs)" << endl; }           // move assignment 
	~Foo(){ cout << "~Foo()" << endl; }
};

int main(int argc, char* argv[])
{
	cout<<"=========="<<endl;
	Foo foo1 = Foo();
	cout<<"=========="<<endl;
	foo1 = Foo();
	cout<<"=========="<<endl;
	Foo  foo2 = foo1;
	cout<<"=========="<<endl;
	foo2 = foo1;
        getchar();
	return 1;
}

实参类型为non-const lvalue reference、const lvalue reference、 const rvalue reference可以匹配到copy ctor和copy assignment。

实参类型为non-const rvalue reference 才能匹配到 move ctor和 move assignment 。

通过这样的方式，让 Foo foo1 = Foo()或 foo1 = Foo()这样的表达式，都可以匹配到 move 语意的版本。

与此同时，让 Foo foo2 = foo1 或 foo2 = foo1 这样的表达式，依然使用 copy 语意的版本。

达到以上效果需要编译时加上-fno-elide-constructors，以此关闭编译器省略创建一个只是为了初始化另一个同类型对象的临时对象的优化。

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
31
32
33
34
35
36
37
38
39
struct Foo
{
	Foo(int a) :a(a){}
	int a;
};

void test1(Foo&& f)
{
// 对于任何类型为 右值引用的变量（当然也包括函数参数），只能由右值来初始化；
}

void test2(Foo& f)
{
//  一个右值，不能被 T& 类型的参数匹配；毕竟这种可以修改的承诺。而修改一个调用后即消失的临时
//  对象上，没有任何意义，反而会导致程序员犯下潜在的错误，因而还是禁止了最好
}

void test3(const Foo& f)
{

}	

Foo f1(1);
test1(f1);  // wrong  cannot bind ‘Foo’ lvalue to ‘Foo&&’ 不能将一个左值绑定到右值引用
test2(f1);  // ok
test3(f1);  // ok

test1(Foo{1});  // ok      Foo{1}是右值
test2(Foo{1});  // wrong   这种做法无意义,invalid initialization of non-const reference of type ‘Foo&’ from an rvalue of type ‘Foo’
test3(Foo{ 1 });  // ok

// ref是左值虽然其类型是右值引用; 
// 一个类型为 右值引用的变量，一旦被初始化之后，临时对象的生命将被扩展，会在其被创建的 scope 内始终有效。
// 看似 ref 被定义的类型为 右值引用，但这仅仅约束它的初始化：只能从一个 右值进行初始化。
// 但一旦初始化完成，它就和一个 左值引用再也没有任何差别：都是一个已存在对象的 标识。
Foo&& ref = Foo{1}; 
test1(ref);    // wrong  ref是左值,test1的形参为右值引用,右值引用的变量只能由右值来初始化 cannot bind ‘Foo’ lvalue to ‘Foo&&’
test2(ref); // ok  
test3(ref); // ok

速亡值

只有右值临时对象可以初始化右值引用变量，从而也只有右值临时变量能够匹配参数类型为 右值引用（T&&）的函数，包括 move 构造函数。

如果程序员就是想把一个左值 move 给另外一个对象，该怎么办？最简单的选择是通过 static_cast 进行类型转换：

1
2
3
4
Foo foo{10};           // foo为左值
Foo&& ref = Foo{10};   // ref为左值  类型为右值引用
Foo obj1 = static_cast<Foo&&>(foo); // move 构 造
Foo obj2 = static_cast<Foo&&>(ref); // move 构 造

我们之前说过，只有 右值，才可以用来初始化一个 右值引用类型的变量，因而也只有 右值才能匹配 move构造。

所以，static_cast<Foo&&>(foo) 表达式，肯定是一个 右值。

但同时，它返回的类型又非常明确的是一个 引用，而这一点又不符合 右值的定义。

因为，所有的右值，都必须是一个 具体类型，不能是不完备类型，也不能是抽象类型，但 引用，无论左值引用，还是右值引用，都可以是不完备类型的引用或抽象类型的引用。这是 左值才有的特征。

对于这种既有左值特征，又和右值临时对象一样，可以用来初始化右值引用类型的变量的表达式，只能将其归为新的类别。C++11 给这个新类别命名为 速亡值 (eXpiring value，简称 xvalue)。

而将原来的 右值，重新命名为 纯右值。而 速亡值和 纯右值合在一起，称为 右值，其代表的含义是，所有可以直接用来初始化 右值引用类型变量的表达式。

同时，由于 速亡值又具备左值特征：可以是不完备类型，可以是抽象类型，可以进行运行时多态。所以，速亡值又和 左值一起被归类为 泛左值（generalized lvalue, 简称 glvalue)。

From

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