int main() {
    int a = 10;
    int& ra = a;  // ra是a的別名
    a += 10;
    cout << ra << endl;  // 輸出20
    ra += 10;
    cout << a << endl;   // 輸出30
    return 0;
}

int& ra;      // ? 錯誤：引用必須初始化
int& ra = a;  // ? 正確

int& ra = NULL;  // ? 錯誤：不能給引用賦空值
int* p = NULL;   // ? 指針可以為空

int a = 10, b = 20;
int& ra = a;
ra = b;  // 這不是讓ra指向b，而是把b的值賦給a（即a = 20）

int a = 10, b = 20;
int* p = &a;   // 指針可以改變指向
p = &b;        // 現(xiàn)在p指向b
*p = 100;      // 修改b的值為100

// C語言：傳值，交換失敗
void Swap(int a, int b) {
    int tmp = a;
    a = b;
    b = tmp;
}
int main() {
    int x = 10, y = 20;
    Swap(x, y);
    // x和y還是10和20，沒變
}

// C語言：傳指針，交換成功
void Swap(int* a, int* b) {
    int tmp = *a;
    *a = *b;
    *b = tmp;
}

// C++：傳引用，交換成功
void Swap(int& a, int& b) {
    int tmp = a;
    a = b;
    b = tmp;
}
int main() {
    int x = 10, y = 20;
    Swap(x, y);     // 調(diào)用時和傳值一樣，但實參被改了
    cout << x << " " << y << endl;  // 輸出20 10
}

// 傳值：拷貝整個Student對象（幾十字節(jié)）
void PrintStudent(Student s) { ... }
// 傳引用：只傳遞地址（4/8字節(jié)），不拷貝
void PrintStudent(const Student& s) { ... }

int a = 10;
int& ra = a;   // 普通引用
ra = 100;      // ? 可以修改
cout << ra;    // ? 可以讀取

int a = 10;
const int& cra = a;  // 常引用，只讀
cout << cra;         // ? 可以讀取
cra = 100;           // ? 錯誤：不能通過常引用修改

int a = 10;        // 普通變量：可讀可寫
const int b = 20;  // 常量：只讀
int& ra = a;        // ? 普通引用引用普通變量
const int& cra = a; // ? 常引用引用普通變量
int& rb = b;        // ? 錯誤：普通引用不能引用常量（權(quán)限超了）
const int& crb = b; // ? 常引用引用常量

int a = 10;
const int& cra = a;  // ?

const int b = 20;
const int& crb = b;  // ?

const int& crx = 30;  // ? 可以！

// 編譯器實際做的事：
int tmp = 30;
const int& crx = tmp;

int a = 10, b = 20;
const int& cr = a + b;  // ? 表達(dá)式結(jié)果是臨時變量，const引用可以綁定

int a = 10, b = 20;
int& ra = a;   // ra是a的別名
ra = b;        // ? 不是讓ra指向b，而是把b的值賦給a（a變成20）

int a = 10;
int& ra = a;
cout << sizeof(ra);  // 輸出4（int的大小），不是指針的大小

int a = 10;
int& ra = a;
int&& rra = ra;  // ? 錯誤：不存在"引用的引用"

Student& func() {
    Student sa{ "S001", "Alice", "F", 20  };
    return sa;   // 返回局部變量的引用
}
int main() {
    Student& p = func();
    printf("%s", p.s_name);  // 可能崩潰，可能亂碼，可能碰巧正確
}

// 返回引用：返回地址，危險
Student& func1() {
    Student sa{ ... };
    return sa;   // 返回地址，sa銷毀后地址失效 ?
}
// 返回值：返回副本，安全
Student func2() {
    Student sa{ ... };
    return sa;   // 返回副本，sa銷毀不影響副本 ?
}

Student& func1() { return sa; }  // 返回類型是引用 → 地址
Student* func2() { return &sa; } // 返回類型是指針 → 地址
Student func3() { return sa; }   // 返回類型是對象 → 副本

Student func() {
    Student sa{ ... };
    return sa;  // 返回副本
}

Student& func() {
    static Student sa{ ... };  // 靜態(tài)變量，生命周期貫穿整個程序
    return sa;
}Student& func() {
    static Student sa{ ... };  // 靜態(tài)變量，生命周期貫穿整個程序
    return sa;
}

Student* func() {
    Student* p = new Student{ ... };  // 堆上分配，手動管理
    return p;
}

int& rbr[5];  // ? 錯誤：不能定義引用數(shù)組

int ar[5] = {1,2,3,4,5};
int(&rar)[5] = ar;  // ? 正確：rar是數(shù)組ar的引用

int ar[5] = {1,2,3,4,5};
cout << sizeof(ar);      // 20（5*4，未退化）
int(*p)[5] = &ar;        // 取數(shù)組地址，未退化
int(&rar)[5] = ar;       // 引用數(shù)組，未退化
int* q = ar;             // 退化：ar變成int*

void funa(int br[5]) {
    cout << sizeof(br);   // 輸出8（指針大?。?，不是20
    // 函數(shù)內(nèi)部不知道數(shù)組有多大，只能通過額外參數(shù)傳入長度
}

void funb(int (&rar)[5]) {
    cout << sizeof(rar);  // 輸出20，保留了數(shù)組大小
    // 函數(shù)內(nèi)部可以直接用sizeof獲取數(shù)組長度
}

// 演示++操作的區(qū)別
int ar[5] = {10,20,30,40,50};
int& ra = ar[0];
int* p = &ar[0];
++ra;   // ar[0]變成11
++p;    // p指向ar[1]

int a = 10;
int& ra = a;
int* p = &a;
// 底層實現(xiàn)：ra和p都是存儲a的地址