int a = 10; // a 是左值（有名字、能取地址）
int* p = &a; // 合法：左值可以取地址
const int b = 20; // b 是 const 左值（有名字、能取地址，但不能修改）
// b = 30; // 錯誤：const 左值不可修改
int arr[5]; 
arr[0] = 1; // arr[0] 是左值（數組元素有地址）

int a = 10;
int b = 20;
// 以下都是右值
100; // 字面量（無名字，不能取地址）
a + b; // 表達式結果（臨時值，無名字）
func(); // 函數返回值（非引用類型時，是臨時值）

int a = 10;
int& ref_a = a; // 正確：左值引用綁定左值（ref_a 是 a 的別名）
ref_a = 20; // 等價于 a = 20，a 現(xiàn)在是 20

// int& ref = 10; // 錯誤：左值引用不能綁定右值（10 是右值）

const int& ref = 10; // 正確：const 左值引用可綁定右值
// 原理：編譯器會生成臨時變量存儲 10，ref 綁定這個臨時變量（臨時變量生命周期被延長至 ref 相同）

void func(const vector<int>& v) { ... } // 傳引用，無拷貝

void increment(int& x) { x++; }
int a = 5;
increment(a); // a 變?yōu)?6

int&& ref1 = 10; // 正確：右值引用綁定純右值（10 是右值）
int a = 10, b = 20;
int&& ref2 = a + b; // 正確：右值引用綁定表達式結果（右值）

int a = 10;
// int&& ref = a; // 錯誤：右值引用不能直接綁定左值

int a = 10;
int&& ref = std::move(a); // 正確：std::move 將 a 轉為右值引用

class MyString {
private:
    char* data; // 存儲字符串的動態(tài)內存
public:
    // 普通構造函數
    MyString(const char* str) {
        size_t len = strlen(str);
        data = new char[len + 1];
        strcpy(data, str);
        cout << "構造函數：分配內存" << endl;
    }
    // 拷貝構造函數（左值引用參數，深拷貝）
    MyString(const MyString& other) {
        size_t len = strlen(other.data);
        data = new char[len + 1];
        strcpy(data, other.data);
        cout << "拷貝構造：深拷貝（性能差）" << endl;
    }
    // 移動構造函數（右值引用參數，直接竊取資源）
    MyString(MyString&& other) noexcept {
        data = other.data; // 直接接管 other 的內存
        other.data = nullptr; // other 放棄資源（避免析構時重復釋放）
        cout << "移動構造：竊取資源（性能好）" << endl;
    }
    ~MyString() {
        if (data) delete[] data;
        cout << "析構函數：釋放內存" << endl;
    }
};
int main() {
    MyString s1("hello"); // 調用普通構造
    MyString s2 = s1; // 調用拷貝構造（s1 是左值，必須深拷貝）
    MyString s3 = MyString("world"); // 調用移動構造（臨時對象是右值，直接竊取資源）
    MyString s4 = std::move(s1); // 調用移動構造（s1 被轉為右值，資源被 s4 竊?。?
    return 0;
}

template <typename T>
void func(T&& t) { // 萬能引用（僅模板中 T&& 才是萬能引用）
    // 根據傳入的參數，t 可能是左值引用或右值引用
}
int main() {
    int a = 10;
    func(a); // 傳入左值，T 推導為 int&，func 實際為 void func(int& t)
    func(20); // 傳入右值，T 推導為 int，func 實際為 void func(int&& t)
    return 0;
}

void target(int& x) { cout << "左值版本" << endl; }
void target(int&& x) { cout << "右值版本" << endl; }
template <typename T>
void func(T&& t) {
    target(t); // 錯誤：t 是引用（有名字），被當作左值處理，始終調用 target(int&)
}
int main() {
    int a = 10;
    func(a); // 傳入左值，期望調用 target(int&) → 實際正確
    func(20); // 傳入右值，期望調用 target(int&&) → 實際錯誤（調用了左值版本）
    return 0;
}

template <typename T>
void func(T&& t) {
    target(std::forward<T>(t)); // 完美轉發(fā)：保持 t 的原始屬性
}
int main() {
    int a = 10;
    func(a); // 傳入左值 → 轉發(fā)為左值 → 調用 target(int&)
    func(20); // 傳入右值 → 轉發(fā)為右值 → 調用 target(int&&)
    return 0;
}

class MyString {
private:
    char* data;
    size_t size;
public:
    // 移動構造函數
    MyString(MyString&& other) noexcept 
        : data(other.data), size(other.size) {
        other.data = nullptr;
        other.size = 0;
    }
    // 移動賦值運算符
    MyString& operator=(MyString&& other) noexcept {
        if (this != &other) {
            delete[] data;
            data = other.data;
            size = other.size;
            other.data = nullptr;
            other.size = 0;
        }
        return *this;
    }
    // 析構函數
    ~MyString() {
        delete[] data;
    }
    // 禁用拷貝（可選）
    MyString(const MyString&) = delete;
    MyString& operator=(const MyString&) = delete;
};

// 包裝器函數
template<typename Func, typename... Args>
auto wrapper(Func&& func, Args&&... args) {
    return std::forward<Func>(func)(std::forward<Args>(args)...);
}
// 工廠函數
template<typename T, typename... Args>
T create(Args&&... args) {
    return T(std::forward<Args>(args)...);
}

int&& ref = 10; // ref 是右值引用，但自身是左值
int& ref2 = ref; // 正確：ref 是左值，可綁定到左值引用

左值/右值
├── 左值 (lvalue)：有名字、可尋址
├── 右值 (rvalue)：臨時對象、字面量
│   ├── 純右值 (prvalue)
│   └── 將亡值 (xvalue)
│
引用類型
├── 左值引用 (&)：綁定左值
├── 右值引用 (&&)：綁定右值
└── 通用引用 (T&&)：模板推導
    └── 完美轉發(fā) (std::forward)