int main() {
    int x = 10;        // x 是左值
    int* p = &x;       // ? 可以對(duì) x 取地址
    int y = 20;
    int* p2 = &(x + y);  // ? 錯(cuò)誤！x+y 是臨時(shí)結(jié)果，不能取地址
    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;          // 合法！賦值表達(dá)式返回左值

42;                   // 純右值：整數(shù)字面量
3.14;                 // 純右值：浮點(diǎn)字面量
true;                 // 純右值：布爾字面量
a + b;                // 純右值：運(yùn)算產(chǎn)生的臨時(shí)結(jié)果
&a;                   // 純右值：取地址產(chǎn)生的臨時(shí)指針
[](int x){return x;}; // 純右值：Lambda 表達(dá)式

#include <utility>
int x = 10;
std::move(x);          // 將亡值：把 x 轉(zhuǎn)成右值
string getString() {
    return "hello";
}
getString();           // 純右值（C++17 前）/ 將亡值（特殊情況）

"hello";   // 左值！C 語(yǔ)言遺留，字符串字面量是 const char[6]
&"hello";  // ? 可以取地址！
42;        // 右值，普通數(shù)字字面量
&42;       // ? 錯(cuò)誤！不能取地址

int a, b;
(a = b) = 3;     // 合法！賦值表達(dá)式返回左值
a = b = c = 0;    // 鏈?zhǔn)劫x值，就是因?yàn)橘x值返回左值
// C++ 中 =
// 1. 把右邊的值賦給左邊
// 2. 整個(gè)表達(dá)式返回左邊的引用（左值）

int x = 10;
++x;       // 返回 x 的引用 → 左值
x++;       // 返回 x 的舊值（臨時(shí)）→ 右值
++++x;     // ? 合法（++x 是左值，可以再 ++）
x++++;     // ? 錯(cuò)誤（x++ 是右值，不能再 ++）

int a = 1, b = 2;
(a > b ? a : b) = 3;  // ? 兩個(gè)都是左值 → 結(jié)果是左值
int x = 1;
(x > 0 ? x : 0) = 3;  // ? 一個(gè)左值一個(gè)右值 → 結(jié)果是右值

struct Point { int x, y; };
Point p = {1, 2};
p.x;              // 左值（p 是左值）
Point{3, 4}.x;    // C++11 后可以是左值（臨時(shí)對(duì)象的成員）

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;     // ? 合法！綁定右值，生命周期延長(zhǎng)
const int& ref2 = x + 1;  // ? 合法！
int x = 10;
const int& ref3 = x;      // ? 也可以綁定左值

// 編譯器大概這樣處理：
const int& ref = 42;
// ↓ 等價(jià)于
// const int __temp = 42;
// const int& ref = __temp;

int&& rref = 10;  // rref 的類(lèi)型是 int&&（右值引用類(lèi)型）
                  // 但 rref 本身是一個(gè)有名字的變量
                  // 所以 rref 是左值！
int x = 10;
int&& rref2 = std::move(x);  // rref2 的類(lèi)型是 int&&
                               // 但 rref2 是左值

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