1--引用的基本语法

引用相当于给变量起别名，其基本语法如下：

数据类型 &别名 = 原名

# include <iostream>

int main(){
    int a = 10;
    int &b = a;

    std::cout << "a = " << a << std::endl;
    std::cout << "b = " << b << std::endl;

    b = 100;
    std::cout << "a = " << a << std::endl;
    std::cout << "b = " << b << std::endl;

    return 0;
}

2--引用的注意事项

① 引用必须初始化：例如 int &b; 是错误的，因为没有进行初始化；

② 引用一旦初始化后，不能进行更改：例如 int &b = a; 表明b为a的别名，后续不能进行 int &b = c的操作，即不能将b更改为c的别名；

# include <iostream>

int main(){
    int a = 10;
    int &b = a;
    int c = 20;
    b = c; // 赋值操作，而不是更改引用 int &b = c; 才是更改引用，这是不允许的

    std::cout << "a = " << a << std::endl;
    std::cout << "b = " << b << std::endl;
    std::cout << "c = " << c << std::endl;

    return 0;
}

3--在函数参数中使用引用

函数传参时，可以利用引用来让形参修饰实参，其优点是可以简化指针来修改实参；

# include <iostream>

// 值传递
void mySwap01(int a, int b){
    int temp = a;
    a = b;
    b = temp;
}

// 地址传递
void mySwap02(int *a, int *b){
    int temp = *a;
    *a = *b;
    *b = temp;
}

// 引用传递
void mySwap03(int &a, int &b){
    int temp = a;
    a = b;
    b = temp;
}

int main(){
    int a = 10, b =20;
    std::cout << "交换前：" << std::endl;
    std::cout << "a = " << a << std::endl;
    std::cout << "b = " << b << std::endl;

    mySwap01(a, b);
    std::cout << "值传递交换后：" << std::endl;
    std::cout << "a = " << a << std::endl;
    std::cout << "b = " << b << std::endl;

    mySwap02(&a, &b);
    std::cout << "地址传递交换后：" << std::endl;
    std::cout << "a = " << a << std::endl;
    std::cout << "b = " << b << std::endl;

    mySwap03(a, b);
    std::cout << "引用传递交换后：" << std::endl;
    std::cout << "a = " << a << std::endl;
    std::cout << "b = " << b << std::endl;

    return 0;
}

引用传递的结果为 a = 10， b = 20，这是因为之前已经进行了地址传递，所以再次交换后相当于交换前的数值；

4--引用作函数的返回值

注意事项：不能返回局部变量的引用，因为局部变量存在于栈区，当函数执行完毕后，局部变量会被操作系统释放；下面的实例中，test01是错误的，而test02是正确的；

int &test01(){
    int a = 10; // 局部变量，存在于栈区
    return a;
}

int &test02(){
    static int a = 10; // 静态变量，存在于全局区
    return a;
}

如果函数的返回值是引用，这个函数调用可以作为左值；

# include <iostream>

int &test02(){
    static int a = 10; // 静态变量，存在于全局区
    return a;
}

int main(){

    int &ref = test02(); // ref为别名
    std::cout << "ref: " << ref << std::endl;

    test02() = 1000; // = 号的左边为左值
    std::cout << "ref: " << ref << std::endl;
    
}

5--引用的本质

引用的本质在 C++ 内部实现是一个指针常量；

# include <iostream>

// 当发现是引用时，转换为 int* const ref = &a;
void func(int& ref){
    ref = 100; // ref是引用，转换为*ref = 100;
}

int main(){
    int a = 10;
    // 自动转换为 int* const ref = &a; 指针常量指向不能更改，这也解释了为什么引用不可以更改
    int &ref = a;
    ref = 20;

    std::cout << "a: " << a << std::endl;
    std::cout << "ref: " << ref << std::endl;
    func(a);
    std::cout << "a = " << a << ", ref: " << ref << std::endl;
    return 0;
}

6--常量引用

常量引用用来修饰形参，防止误操作；通过在函数形参列表中，使用const来修饰形参，从而防止形参改变实参；

# include <iostream>

void showValue(int &val){
    val = 1000; // 这个是误操作
    std::cout << "val: " << val << std::endl;
}

int main(){
    int a = 10;
    const int &ref1 = a; // 引用必须引用一块合法的内存空间

    const int &ref2 = 20; // 不使用const将报错
    // 使用const相当于：
    // int temp = 20;
    // int &ref2 = temp;
    // 加入const后为只读，不能修改，即ref2 = 30会报错
    
    int b = 20;
    showValue(b);
    std::cout << "b = " << b << std::endl;
    return 0;
}

# include <iostream>

void showValue(const int &val){
    // val = 1000; // 这个是误操作，当使用const之后，如果检测到误操作就会报错
    std::cout << "val: " << val << std::endl;
}

int main(){
    int a = 10;
    const int &ref1 = a; // 引用必须引用一块合法的内存空间

    const int &ref2 = 20; // 不使用const将报错
    // 使用const相当于：
    // int temp = 20;
    // int &ref2 = temp;
    // 加入const后为只读，不能修改，即ref2 = 30会报错

    int b = 20;
    showValue(b);
    std::cout << "b = " << b << std::endl;
    return 0;
}