C++ 值类别定义与区分（左值、纯右值、亡值）、std::move 函数

一、值类别（左值、纯右值、亡值）

二、std::move

一、值类别

表达式

何谓表达式？
由运算符和运算对象构成的计算式。字面量、变量、函数返回值都是表达式。
表达式返回的结果，有两个属性：类型和值类别。

1. 左值

性质：

与泛左值相同（见下文）
可以通过 '&' 取到左值的地址
可修改的左值可用作 '=' 的左操作数
可用于初始化左值引用

int i;               // 左值
cout << &i << endl;  // 可以通过 '&' 取到左值的地址
i = 3;               // 可修改的左值可用作 '=' 的左操作数
int& j = i;          // 可用于初始化左值引用

常见的左值表达式包括：

变量，对象。例如， int i
返回类型为左值引用的函数调用或重载运算符表达式，例如 str1 = str2、++it
所有内建的赋值及复合赋值表达式，例如 a = b、a += b
内建的前置自增、前置自减，例如 ++i、--i
内建的间接寻址表达式，例如 *p
字符串字面量，例如 "hello world"
内建的下标表达式，例如 a[n]
迭代器是左值，例如 vecotr<int>::iterator iter

2. 纯右值

性质：

与右值相同（见下文）
纯右值不能多态：它所标识的对象的动态类型始终为该表达式的类型
纯右值不能具有不完整类型
纯右值不能具有抽象类类型或数组类型

常见的纯右值表达式包括：
除了字符串字面量之外的，其他字面量，例如 123、true、nullptr
返回类型是非引用的函数调用或重载运算符表达式，例如 str1 + str2、it++
内建的后置自增与后置自减表达式，例如 i++、i--
内建的算术表达式，例如 a + b
内建的逻辑表达式，例如 !a
内建的比较表达式，例如 a < b
内建的取值表达式，例如 &a
this 指针
枚举项

3. 亡值

性质：
亡值实际上式 C++ 11 引入了 右值引用的概念而引入的，在C++ 11 之前，右值可以等价于纯右值。亡值与右值引用息息相关。

与右值相同
与泛左值相同

常见的亡值表达式：
返回类型为对象的右值引用的函数调用或重载运算符表达式，例如 std::move(x)
当使用右值来初始化对象，或者为对象赋值时，会调用 移动构造函数 或 移动赋值运算符来移动资源，当该右值完成初始化或赋值的任务时，它的资源已经移动给了新的对象，此右值也即将被销毁，所以称为亡值。

混合类别

泛左值

泛左值表达式包括左值、亡值
性质：

泛左值可以通过左值到右值、数组到指针、或者函数到指针隐式转换成纯右值
例子 1 —— 左值到右值：
int i = 1;
编译器在内存中为变量 i 开辟了一段具有 sizeof(int) 个字节的空间，初始化为 1。此时，i 属于左值。
i + 1；
由于 + 双目运算符要求为右值，而 i 为左值，此时系统从 i 的空间取出整数 1，交给 + 运算符。这个过程就是一个 左值到右值 的转换。此过程中，原本的左值 i 被右值 1 替代，但是 i 本身的性质没有改变，依然是一个左值。

例子2 —— 数组到指针

void func(int a[5])
{
     \\ todo
}

int main()
{
    int a[5] = {0};
    func(a);

    return 0;
}

数组之间是不能相互赋值的，也不能用数组类型作为函数的参数或返回值。对于数组类型有一条特殊的规则：数组类型做右值使用时，自动转换成指向数组首元素的指针。所以 func(a) 实际上是传了指针类型的参数作为右值。

泛左值可以是多态的：其所标识的对象的动态类型不必是该表达式的静态类型
静态类型：变量声明时的类型，或者表达式生成的类型（自主声明，编译期已确定）
动态类型：变量或者表达式表示的内存中的对象类型（运行时才确定）
例如：
A *pa = new B;
*pa 作为左值的静态类型为 A，而动态类型为 B，但是如果是 &pa，动态类型是不允许和声明时不一样的。
泛左值可以具有不完整类型，只要表达式中容许
不完整类型：
- 已声明（如前置声明）但未定义的类类型
- 未知边界数组
- 不完整类型元素的数组
- 枚举类型
emmm 但是具体的例子，并没有找到。相反，个人认为不完整的类型不应该为左值，因为不完整类型没有实际内存大小，编译器只知道有这么个类型，但是不知道要为该类型对象分配多少内存。

右值

右值包括纯右值、亡值
性质：

右值不能由内建的取指运算符取地址：&int()、&i++、&1、&std::move(x) 都是非法的
右值不能用作内建赋值运算符及内建复合赋值运算符的左操作数：std::move(x) = y 是非法的
右值可以用于初始化 const 左值引用，这种情况下，该右值所标志的对象的生存期被延长到该引用的作用域结尾： const int& i = 5，const int& i = std::move(j)

总结与区分

一条表达式，要么是左值，要么是右值（纯右值、亡值）
左值可以被当作右值使用，出现在赋值语句 = 右侧；
左值出现在 = 右侧时，用的是对象的值，这时候可以说这个对象具有了右值属性（但是不是右值）；
左值出现在赋值语句 = 左侧时，使用的是对象在内存中的地址，这时候可以说这个对象具有左值属性；
也就是说，一个左值，可能同时具有左值属性和右值属性；
但是右值不能出现在赋值语句 = 左侧。
通过判断运算符在字面量上是否可以操作，基本可以判断此运算符是否需要用到左值。但是运算符是否需要左值或右值，和最终的表达式结果为左值或无关。
例如：后置自增运算符，需要左值（9++ 是不被允许的），但是返回的结果 i++ 是右值。
字符串字面量为左值，其他字面量为右值
C++将字符串字面量实现为 char 型数组，其中的每个字符都被分配了空间，所以字符串字面量是实实在在的左值。下面的操作是被允许的：

    cout << &"hello world" << endl;
    const char *ps = "hello world";
    const char (*p)[12]= &"hello world";

前置自增自减为左值，后置自增自减为右值
++i 是对 i 加1后，返回 i，所以 ++i 的结果是具名的，就是 i。而 i++ 是对 i 进行一次拷贝，将拷贝得到的值作为返回结果，然后再对 i 加1，所以 i++ 是不具名的。

 &i;     // 得到 i 的地址
 &++i; // 是允许的，返回和 &i 一样的结果
 &i++; // 是非法的

解引用表达式*p是左值，取地址表达式&a是纯右值。
p 得到的是指向p指向的实体，&(p)得到的是这一实体的地址，也就是 p 的值。而 &p 得到的是 p 的地址，相当于 unsigned int 型的字面量，是右值（&(&p) 是非法的）。
具名的右值引用是左值，不具名的右值引用是右值。
函数内的形参都是左值， void f(int&& val) val 是右值引用，但是本身是左值。
临时对象都是右值。

二、std::move

std::move(t)

std::move 用于指示对象 t 可以“被移动”，即允许 t 到另一对象的有效率的资源传递。特别地，std::move 生成标识其参数 t 的亡值表达式。它准确地等价于到右值引用类型地 static_cast。
系统建议，调用 std::move(t) 后，除了对 t 进行赋值或者销毁操作，后续将不再对对象 t 进行其他操作（但是实际上仍然可以进行操作，虽然有可能出现异常）。

std::move(val) 能将左值强制转为右值，被右值引用绑定（但是 val 本身还是左值，只是 std::move(val)返回的值类别为右值）

int main()
{
    int i = 0;
    int&& r = std::move(i); // i 通过 move 转换为右值，绑定到了右值引用 r 上
    
    cout << &i << endl;
    cout << &r << endl;     // r 绑定到对象 i 上，二者的地址相同
    
    i = 10;                 // i 本身还是左值，还是可以对其进行操作，但是不建议再对其操作
}

通过 dst = std::move(src) 进行赋值、复制操作时，会触发移动构造函数、移动运算符的调用，将对象 src 的数据移动至对象 dst。注意这里的数据移动，并不是 std::move(src) 做的，move 只是单纯地将左值强制转换为右值。数据的移动，是在移动构造函数，移动运算符重载中实现的。

int main()
{
    string src = "hello world";
    
    string dst = std::move(src);    // 触发移动构造函数 
    
    cout << dst << endl;    // src 的数据，被移动到 dst。此时 dst == "hello world"
    cout << src << endl;    // src == ""
    
    
    std::move(dst);         // 单纯调用 move 并不会发生数据的移动 
    string&& dst2 = std::move(dst); // 通过 move 右值引用也不会发生数据的移动
                                    // 因为没有新的对象产生，不会调用到移动构造函数 
    
    cout << dst << endl;
    
    return 0;   
}

string 的移动构造函数的实现：

#if __cplusplus >= 201103L
      /**
       *  @brief  Move construct string.
       *  @param  __str  Source string.
       *
       *  The newly-created string contains the exact contents of @a __str.
       *  @a __str is a valid, but unspecified string.
       **/
      basic_string(basic_string&& __str)
#if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
      noexcept // FIXME C++11: should always be noexcept.
#endif
      : _M_dataplus(__str._M_dataplus)
      {
#if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
    __str._M_data(_S_empty_rep()._M_refdata());
#else
    __str._M_data(_S_construct(size_type(), _CharT(), get_allocator()));
#endif
      }