C++-左值和右值

左值和右值

什么是表达式

表达式由一个或多个运算对象（operand）组成，对表达式求值得到一个结果(result)，字面值和变量是最简单的表达式，其结果就是字面值和变量的值。运算符（operator）和运算对象组合可以生成复杂的表达式。

左值和右值

C++的表达式的结果要么是左值（lvalue），要么是右值（rvalue）：

• 左值指向一个特定的内存位置
• 右值不指向特定的内存位置
  通常来说右值是临时的和短暂的，而左值有更长的生存期。一个有意思的比喻是：左值是容器而右值是容器内的东西，没有容器，东西将很快过期。
  举个例子：

int x=666;// ok

666是一个右值，因为一个数字（字面值常量）没有特定的内存地址，它仅在运行时临时保存在寄存器中
x变量有特定的内存地址，所以它是一个左值。
等号运算符要求左边的运算对象是一个左值，所以这里的表达式是合法的

int* y = &x;// ok

这里取址运算符接受一个左值x生成一个右值，并把这个右值保存到y中

int y;
666 = y; // error!

前面说过666是一个右值，没有特定的内存地址，把y的值保存到一个没有特定地址的内存中，这从常理上来说是没有意义的。
gcc会报错：

error: lvalue required as left operand of assignment

类似的

int* y = &666; // error!

gcc报错：

error: lvalue required as unary '&' operand`

取址运算符要求一个左值作为输入，因为只有左值才有特定的地址可以取址

函数返回左值和右值

int setValue()
{
    return 6;
}

// ... somewhere in main() ...

setValue() = 3; // error!

这是错误的，因为赋值运算符要求左边的运算符是一个左值（准确的说是可修改的左值，后面解释），而函数返回的是右值

int global = 100;

int& setGlobal()
{
    return global;    
}

// ... somewhere in main() ...

setGlobal() = 400; // OK

这是对的，因为函数返回了global变量的引用，它指向了global的地址，是一个左值，因此赋值表达式是合法的。

左值到右值的转换

根据C++规范，+运算符要求两个右值作为输入，并返回右值，观察如下代码

int x = 1;
int y = 3;
int z = x + y;   // ok

x和y都是左值，但是+要求两个右值，这是怎么回事？
这是因为底层发生了隐式的左值到右值的转换，很多运算符都会执行这种隐式转换。

左值引用

那么反过来，右值能转化为左值吗？不行。这并非技术限制，而是编程语言设计的限制。

int y = 10;
int& yref = y;
yref++;        // y is now 11

这里yref引用指向了y的地址，是一个左值引用。如果直接这么写

int& yref = 10;  // will it work?

10是一个右值，没有特定的内存地址，而引用要求指向特定内存地址，因此这将出错。这就是“禁止右值转为左值”的一个例子。
试想一下，如果这种转换是合法的，那么就可以通过这个引用改变字面量常量，这听起来完全没有意义。最重要的是，如果右值消失，那么引用将指向什么？
下面的代码错误原因正是如此

void fnc(int& x)
{
}

int main()
{
    fnc(10);  // Nope!
    // This works instead:
    // int x = 10;
    // fnc(x);
}

一种解决方法是，声明一个变量保存10，再作为实参传入

常量左值引用

C++语言允许将常量左值绑定到右值，因此如下代码正确

const int& ref = 10;  // OK!

背后的思想在于：引用一个右值存在刚刚说的两个问题：

1. 改变字面量常量没有意义
2. 右值消失
   如果我们让引用成为常量，就解决了这两个问题。

声明一个右值引用，给一个临时内存位置分配一个名称，这使得程序的其他部分访问该内存位置成为了可能，并且可以将这个临时位置变成一个左值。
左值表达式的求值结果是一个对象或者一个函数。当一个对象被用作右值时，用的时对象的值（内容），当对象被用作左值时，用的时候对象的身份（内存中的位置）
同理

void fnc(const int& x)
{
}

int main()
{
    fnc(10);  // OK!
}

实际上编译器创建了一个隐藏的变量来保存字面量常量，引用x实际上绑定到了这个变量，在函数中我们甚至可以打印x的地址。
当我们写下

// the following...
const int& ref = 10;

编译器为我们转换为

// ... would translate to:
int __internal_unique_name = 10;
const int& ref = __internal_unique_name;

参考链接：

1. https://www.internalpointers.com/post/understanding-meaning-lvalues-and-rvalues-c