C++ 引用详解附代码

一、什么是引用？

我们一般所说的引用通常指的就是“左值引用”，下面也仅对此讨论。

引用（reference）也可以称为别名，它为对象起了另外一个名字，引用类型引用另外一种类型。

下面我们简单演示如何使用引用：

#include<iostream>
using namespace std;

int main()
{
    int a = 1;
    int& b = a; // b是a的引用

    cout << &a << endl;
    cout << &b << endl;

    return 0;
}

这里b是a的引用，也就是说，我们给a起了另一个名字——b，因此不同于赋值，a和b是同一个对象的不同名称。

我们从输出结果也可以看到，两个变量的地址相同，变量a的地址是在它定义时系统随机分配的，但b不是，b的地址是根据自身引用的变量来分配的。因此，在引用变量b定义之时，必须先初始化，而不能先声明再赋值。

当然，一个变量可以有多个引用，我们还可以再 int& c = a;

int a = 1;
int& b; b = a; // 这种先声明再负值的写法是错误的！

二、使用引用的注意

2.1 引用只能使用一次

#include<iostream>
using namespace std;

int main()
{
    int a = 1; int c = 2;
    int& b = a;
    b = c;

    cout << a << endl; // 输出：2
    cout << b << endl; // 输出：2

    return 0;
}

对于上面的解释：当b成为a的引用后，它就不能再引用别的对象，所谓b=c 并不是b又改成了c的引用，而是a和b共同指向的对象被赋值为c。

2.2 非常量引用的初始值必须为左值

先简单介绍一下什么是左值：

#include<iostream>
using namespace std;

int main()
{
    int a = 1;
    const int& b = a;

    cout << &a << endl;
    cout << &b << endl;

    //cout << &(a + 1) << endl;  // 错误的写法
    //cout << &(b + 1) << endl;  // 错误的写法
    
    return 0;
}

常规变量（比如上面的a）和 const 变量（比如上面的b） 都可视为左值，因为可通过地址访问他们，它们是在内存中确确实实的开了空间的。a+1和b+1就不能通过通过地址寻访。

常规变量视为可修改的左值，const变量视为不可修改的左值。

非常量引用的初始值必须为左值：

#include<iostream>
using namespace std;

int main()
{
    int a = 1;
    
    //int& b = a + 1;  // a+1不是左值，这是错误写法
    const int& b = a + 1; // 这样就可以通过了，b的值为2，且不可修改

    return 0;
}

三、引用的权限问题

我们上面有提到，常规变量视为可修改的左值，const变量视为不可修改的左值。对于引用和指针，const和非const涉及到了权限的放大与缩小，我们只能缩小权限，不能将权限放大。

权限缩小和放大规则：仅仅适用于引用和指针间，下面我们仅讨论引用（指针同理）。

#include<iostream>
using namespace std;

int mian()
{
    int a = 1;
    const int& b = a;
    // 虽然a和b都指向同一个对象，但是b的权限没有a的大。
    // b是a的const类型引用，我们可以通过a修改其对象的值，但是不能通过b修改其对象的值。

    const int c = 2;
    // int& d = c; // 错误
    // c是不可修改的类型，但是d引用c后反而可以修改了，这属于权限的放大，是错误的
    const int& d = c;
    // 但是引用类型也是const就可以

    return 0;
}

再次强调：上面权限的放大与缩小只适用于引用和指针，不适用于赋值；

四、引用的具体应用

4.1 引用做参数

#include<iostream>
using namespace std;

void swap_c(int* p1, int* p2)
{
    // 这里p1指向a的地址，p2指向b的地址，交换*p1与*p2就是交换a和b
    int tmp = *p1;
    *p1 = *p2;
    *p2 = tmp;
}

void swap_cpp(int& r1, int& r2)
{
    // 这里r1是a的引用，r2是b的引用，交换r1与r2就是交换a和b
    int tmp = r1;
    r1 = r2;
    r2 = tmp;
}

int main()
{
    int a = 0, b = 1;

    // C语言学了指针后可以传地址交换a和b
    swap_c(&a, &b); // 传的是a和b的地址
    
    // C++中学了引用后可以传引用
    swap_cpp(a, b); // 传的是a和b的引用

    // 二者取其一就好
    return 0;
}

引用传参的好处：没有开额外的空间，修改原值也很方便，省时间，省空间。

4.2 引用做返回值

#include<iostream>
using namespace std;

static int n = 0;
int& count()
{
    ++n;
    return n; // 出了函数作用域后n还存在
}

int main()
{
    int& ret = count(); // ret为1
    count(); // ret为2
    count(); // ret为3

    return 0;
}

注意：使用引用做返回值时一定要谨记，被返回的对象出了函数的作用域之后一定要还存在，否则就极有可能出错。

比如下面：

#include<iostream>
using namespace std;

int& Add(int a, int b)
{
    int c = a + b;
    return c;
    //如果返回变量c是一个局部变量时，引用返回是不安全的
}

int main()
{
    int& ret = Add(1, 2);
    cout << "ret:" << ret << endl; // c出了Add之后就不存在了
    
    return 0;
}

c出了Add函数之后就不存在了，所占用的空间也已经还给了操作系统，再返回c的引用就失去了原本的意义。

总结:一个函数要使用引用返回，返回变量出了这个函数的作用域还在，就可以使用引用返回，否则就不安全。

全局变量、静态变量可以使用引用返回。

五、引用特性总结

1. 一个变量可以有多个引用，但引用只能使用一次。

2. 非常量引用的初始值必须为左值。

3. 与指针类似，引用权限只可以缩小或平级，决不能放大。

4. 使用引用做返回值时，被返回的对象出了函数的作用域之后一定要还存在。