int main()
{
    int i = 0;
    i = 1;                  // i是變量，可修改左值，能放在賦值號左側(cè)
    const int ci = 5;
    // ci = 6;             // 報錯：const左值不可修改，但&ci可獲取地址，仍是左值
    int* pi = &i;
    *pi = 1;                // *pi對指針解引用，左值
    int arr[5] = {0};
    arr[0] = 1;             // 數(shù)組元素，左值
    struct { int m_a; } st, *pst = &st;
    st.m_a = 1;             // 結(jié)構(gòu)體成員，左值
    pst->m_a = 2;
    return 0;
}

int getNum()
{
    return 100;
}
int main()
{
    int i = 0, c = 0;
    i = 42;                  // 字面值42，純右值
    c = 'a';                 // 字面值'a'，純右值
    i = 1 + 2;               // 算術(shù)表達式結(jié)果，純右值
    i = (c != 'a');          // 邏輯表達式結(jié)果，純右值
    i = getNum();            // 非引用返回值，純右值
    int&& rri = std::move(i);// std::move(i)的結(jié)果，將亡值，右值
    return 0;
}

int main()
{
    int a = 10;
    int& ra = a;             // 正確：非const左值引用綁定左值
    // int& rb = 10;         // 報錯：非const左值引用無法綁定右值
    const int& rca = a;      // 正確：const左值引用綁定左值
    const int& rcb = 10;     // 正確：const左值引用綁定右值
    // rcb = 20;             // 報錯：const引用無法修改綁定對象
    return 0;
}

類型&& 引用名 = 右值表達式;

#include <iostream>
using namespace std;
int getNum()
{
    return 100;
}
void func(int&& rri)
{
    rri = 0;
}
int main()
{
    // 1. 右值引用必須綁定右值
    int&& ri0 = 42;          // 正確：綁定字面量純右值
    int&& ri1 = 1 + 2;       // 正確：綁定表達式結(jié)果純右值
    int&& ri2 = getNum();    // 正確：綁定函數(shù)返回值純右值
    // int&& ri3 = ri0;      // 報錯：ri0是右值引用變量，本身是左值，無法綁定
    // 2. 可通過右值引用修改綁定的對象
    ri0 = 100;
    cout << "ri0 = " << ri0 << endl; // 輸出：ri0 = 100
    // 3. 可獲取右值引用的地址（證明它本身是左值）
    int* pi = &ri0;
    *pi = 200;
    cout << "*pi = " << *pi << ", ri0 = " << ri0 << endl; // 輸出：*pi = 200, ri0 = 200
    // 4. 右值引用作為函數(shù)參數(shù)，接收右值
    func(1 + 2);
    return 0;
}

#include <iostream>
#include <string>
using namespace std;
int main()
{
    string str = "Hello World!";
    cout << "move前：str = " << str << endl;
    // std::move將str左值轉(zhuǎn)為右值，觸發(fā)string的移動構(gòu)造函數(shù)
    string tmp = std::move(str);
    cout << "move后：str = " << str << endl;  // 結(jié)果未定義，標(biāo)準(zhǔn)僅保證str可析構(gòu)
    cout << "move后：tmp = " << tmp << endl;
    return 0;
}

#include <iostream>
#include <cstring>
using namespace std;
class MyString
{
public:
    char* data;
    size_t len;
    // 普通構(gòu)造函數(shù)
    MyString(const char* str)
    {
        len = strlen(str);
        data = new char[len + 1];
        strcpy(data, str);
        cout << "構(gòu)造函數(shù)：分配內(nèi)存，地址=" << (void*)data << "，內(nèi)容=" << data << endl;
    }
    // 拷貝構(gòu)造函數(shù)（深拷貝）
    MyString(const MyString& other)
    {
        len = other.len;
        data = new char[len + 1];
        strcpy(data, other.data);
        cout << "拷貝構(gòu)造函數(shù)：深拷貝內(nèi)存，新地址=" << (void*)data << "，內(nèi)容=" << data << endl;
    }
    // 拷貝賦值運算符（深拷貝）
    MyString& operator=(const MyString& other)
    {
        if (this == &other)
        {
            return *this;
        }
        // 釋放自身原有資源
        delete[] data;
        // 深拷貝源對象資源
        len = other.len;
        data = new char[len + 1];
        strcpy(data, other.data);
        cout << "拷貝賦值運算符：深拷貝內(nèi)存，新地址=" << (void*)data << "，內(nèi)容=" << data << endl;
        return *this;
    }
    // 析構(gòu)函數(shù)
    ~MyString()
    {
        if (data)
        {
            cout << "析構(gòu)函數(shù)：釋放內(nèi)存，地址=" << (void*)data << "，內(nèi)容=" << data << endl;
            delete[] data;
        }
        else
        {
            cout << "析構(gòu)函數(shù)：資源已轉(zhuǎn)移，無需釋放" << endl;
        }
    }
};
MyString createString()
{
    MyString str("Hello C++");
    return str; // 返回臨時對象，觸發(fā)拷貝構(gòu)造
}
int main()
{
    MyString str1("Hello World");
    MyString str2 = str1; // 觸發(fā)拷貝構(gòu)造
    MyString str3 = createString(); // 臨時對象觸發(fā)拷貝構(gòu)造，隨后銷毀
    return 0;
}

#include <iostream>
#include <cstring>
using namespace std;
class MyString
{
public:
    char* data;
    size_t len;
    // 普通構(gòu)造函數(shù)
    MyString(const char* str)
    {
        len = strlen(str);
        data = new char[len + 1];
        strcpy(data, str);
        cout << "構(gòu)造函數(shù)：分配內(nèi)存，地址=" << (void*)data << "，內(nèi)容=" << data << endl;
    }
    // 拷貝構(gòu)造函數(shù)（深拷貝）
    MyString(const MyString& other)
    {
        len = other.len;
        data = new char[len + 1];
        strcpy(data, other.data);
        cout << "拷貝構(gòu)造函數(shù)：深拷貝內(nèi)存，新地址=" << (void*)data << "，內(nèi)容=" << data << endl;
    }
    // 移動構(gòu)造函數(shù)（右值引用參數(shù)，資源轉(zhuǎn)移）
    // noexcept關(guān)鍵字：告訴編譯器該函數(shù)不會拋出異常，STL容器會優(yōu)先調(diào)用
    MyString(MyString&& other) noexcept
    {
        // 直接轉(zhuǎn)移源對象的資源，無需深拷貝
        data = other.data;
        len = other.len;
        // 源對象指針置空，避免析構(gòu)時釋放資源
        other.data = nullptr;
        other.len = 0;
        cout << "移動構(gòu)造函數(shù)：轉(zhuǎn)移資源，目標(biāo)地址=" << (void*)data << endl;
    }
    // 拷貝賦值運算符（深拷貝）
    MyString& operator=(const MyString& other)
    {
        if (this == &other)
        {
            return *this;
        }
        delete[] data;
        len = other.len;
        data = new char[len + 1];
        strcpy(data, other.data);
        cout << "拷貝賦值運算符：深拷貝內(nèi)存，新地址=" << (void*)data << "，內(nèi)容=" << data << endl;
        return *this;
    }
    // 移動賦值運算符（右值引用參數(shù)，資源轉(zhuǎn)移）
    MyString& operator=(MyString&& other) noexcept
    {
        if (this == &other)
        {
            return *this;
        }
        // 釋放自身原有資源
        delete[] data;
        // 轉(zhuǎn)移源對象資源
        data = other.data;
        len = other.len;
        // 源對象指針置空
        other.data = nullptr;
        other.len = 0;
        cout << "移動賦值運算符：轉(zhuǎn)移資源，目標(biāo)地址=" << (void*)data << endl;
        return *this;
    }
    // 析構(gòu)函數(shù)
    ~MyString()
    {
        if (data)
        {
            cout << "析構(gòu)函數(shù)：釋放內(nèi)存，地址=" << (void*)data << "，內(nèi)容=" << data << endl;
            delete[] data;
        }
        else
        {
            cout << "析構(gòu)函數(shù)：資源已轉(zhuǎn)移，無需釋放" << endl;
        }
    }
};
MyString createString()
{
    MyString str("Hello C++");
    return str;
}
int main()
{
    MyString str1("Hello World");
    MyString str2 = std::move(str1); // 觸發(fā)移動構(gòu)造，轉(zhuǎn)移str1的資源
    MyString str3 = createString(); // 臨時對象是右值，觸發(fā)移動構(gòu)造
    str3 = MyString("Hello Move"); // 臨時對象觸發(fā)移動賦值
    return 0;
}

// 模板參數(shù)推導(dǎo)，T&&是萬能引用
template<typename T>
void func(T&& arg)
{
}

// 具體類型，int&&是普通右值引用
void func2(int&& arg)
{
}

int main()
{
    int a = 10;
    func(a);  // 正確：萬能引用綁定左值
    func(10); // 正確：萬能引用綁定右值
    // func2(a); // 報錯：普通右值引用無法綁定左值
    func2(10); // 正確：普通右值引用綁定右值
    return 0;
}

#include <iostream>
#include <utility>
using namespace std;
// 重載函數(shù)，區(qū)分左值和右值參數(shù)
void process(int& x)
{
    cout << "左值引用版本被調(diào)用，值=" << x << endl;
}
void process(int&& x)
{
    cout << "右值引用版本被調(diào)用，值=" << x << endl;
}
// 不使用完美轉(zhuǎn)發(fā)的模板函數(shù)
template<typename T>
void noForward(T&& arg)
{
    cout << "無完美轉(zhuǎn)發(fā)：";
    process(arg); // arg是有名字的變量，本身是左值，永遠調(diào)用左值版本
}
// 使用完美轉(zhuǎn)發(fā)的模板函數(shù)
template<typename T>
void withForward(T&& arg)
{
    cout << "有完美轉(zhuǎn)發(fā)：";
    process(std::forward<T>(arg)); // 完美轉(zhuǎn)發(fā)，保留原始左值/右值屬性
}
int main()
{
    int a = 5;
    cout << "===== 傳入左值a =====" << endl;
    noForward(a);
    withForward(a);
    cout << "\n===== 傳入右值10 =====" << endl;
    noForward(10);
    withForward(10);
    return 0;
}

void func(int&& x)
{
}
void test(int&& arg)
{
    // func(arg); // 報錯：arg是右值引用變量，本身是左值
    func(std::move(arg)); // 正確
}

class Test
{
public:
    // 這里的T&&不是萬能引用，因為類實例化時T已經(jīng)確定，沒有參數(shù)推導(dǎo)
    template<typename T>
    void func(T&& arg);
};