C++引用概念及用法全解

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;        // 现在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);     // 调用时和传值一样，但实参被改了
    cout << x << " " << y << endl;  // 输出20 10
}

// 传值：拷贝整个Student对象（几十字节）
void PrintStudent(Student s) { ... }

// 传引用：只传递地址（4/8字节），不拷贝
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;        // ❌ 错误：普通引用不能引用常量（权限超了）
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;  // ✅ 表达式结果是临时变量，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{ ... };  // 静态变量，生命周期贯穿整个程序
    return sa;
}Student& func() {
    static Student sa{ ... };  // 静态变量，生命周期贯穿整个程序
    return sa;
}

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

int& rbr[5];  // ❌ 错误：不能定义引用数组

int ar[5] = {1,2,3,4,5};
int(&rar)[5] = ar;  // ✅ 正确：rar是数组ar的引用

int ar[5] = {1,2,3,4,5};
cout << sizeof(ar);      // 20（5*4，未退化）

int(*p)[5] = &ar;        // 取数组地址，未退化
int(&rar)[5] = ar;       // 引用数组，未退化

int* q = ar;             // 退化：ar变成int*

void funa(int br[5]) {
    cout << sizeof(br);   // 输出8（指针大小），不是20
    // 函数内部不知道数组有多大，只能通过额外参数传入长度
}

void funb(int (&rar)[5]) {
    cout << sizeof(rar);  // 输出20，保留了数组大小
    // 函数内部可以直接用sizeof获取数组长度
}

// 演示++操作的区别
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;
// 底层实现：ra和p都是存储a的地址