C++左值与右值核心判断方法

int main() {
    int x = 10;        // x 是左值
    int* p = &x;       // ✅ 可以对 x 取地址
    int y = 20;
    int* p2 = &(x + y);  // ❌ 错误！x+y 是临时结果，不能取地址
    return 0;
}

int x = 10;           // x 是左值
int* p = &x;          // *p 是左值（可以 &(*p)）
int arr[5] = {1,2,3}; // arr[2] 是左值
string s = "hello";
s[0];                 // 左值，返回 char&
int a = 1, b = 2;
(a = b) = 3;          // 合法！赋值表达式返回左值

42;                   // 纯右值：整数字面量
3.14;                 // 纯右值：浮点字面量
true;                 // 纯右值：布尔字面量
a + b;                // 纯右值：运算产生的临时结果
&a;                   // 纯右值：取地址产生的临时指针
[](int x){return x;}; // 纯右值：Lambda 表达式

#include <utility>
int x = 10;
std::move(x);          // 将亡值：把 x 转成右值
string getString() {
    return "hello";
}
getString();           // 纯右值（C++17 前）/ 将亡值（特殊情况）

"hello";   // 左值！C 语言遗留，字符串字面量是 const char[6]
&"hello";  // ✅ 可以取地址！
42;        // 右值，普通数字字面量
&42;       // ❌ 错误！不能取地址

int a, b;
(a = b) = 3;     // 合法！赋值表达式返回左值
a = b = c = 0;    // 链式赋值，就是因为赋值返回左值
// C++ 中 =
// 1. 把右边的值赋给左边
// 2. 整个表达式返回左边的引用（左值）

int x = 10;
++x;       // 返回 x 的引用 → 左值
x++;       // 返回 x 的旧值（临时）→ 右值
++++x;     // ✅ 合法（++x 是左值，可以再 ++）
x++++;     // ❌ 错误（x++ 是右值，不能再 ++）

int a = 1, b = 2;
(a > b ? a : b) = 3;  // ✅ 两个都是左值 → 结果是左值
int x = 1;
(x > 0 ? x : 0) = 3;  // ❌ 一个左值一个右值 → 结果是右值

struct Point { int x, y; };
Point p = {1, 2};
p.x;              // 左值（p 是左值）
Point{3, 4}.x;    // C++11 后可以是左值（临时对象的成员）

int x = 10;
int& ref1 = x;         // ✅ x 是左值
int& ref2 = 42;        // ❌ 42 是右值
int& ref3 = x + 1;     // ❌ x+1 是右值
int* p = &x;
int& ref4 = *p;        // ✅ *p 是左值

const int& ref1 = 10;     // ✅ 合法！绑定右值，生命周期延长
const int& ref2 = x + 1;  // ✅ 合法！
int x = 10;
const int& ref3 = x;      // ✅ 也可以绑定左值

// 编译器大概这样处理：
const int& ref = 42;
// ↓ 等价于
// const int __temp = 42;
// const int& ref = __temp;

int&& rref = 10;  // rref 的类型是 int&&（右值引用类型）
                  // 但 rref 本身是一个有名字的变量
                  // 所以 rref 是左值！
int x = 10;
int&& rref2 = std::move(x);  // rref2 的类型是 int&&
                               // 但 rref2 是左值

void foo(int& x)  { cout << "左值引用" << endl; }
void foo(int&& x) { cout << "右值引用" << endl; }
int main() {
    int&& rref = 10;  // rref 是左值！
    foo(rref);        // 调用 foo(int&) — 输出"左值引用"
    foo(std::move(rref));  // 调用 foo(int&&) — 输出"右值引用"
}