【C++】引用详解-Toy模板网

这篇具有很好参考价值的文章主要介绍了【C++】引用详解。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

前言

在学习C语言时，我们通常会遇到两个数交换的问题，为了实现这一功能，我们会编写一个经典的Swap函数，如下所示：

void Swap(int* a, int* b)
{
    int tmp = *a;
    *a = *b;
    *b = tmp;
}

然而，这个Swap函数看起来可能有些繁琐，需要使用指针和解引用操作符。相比之下，C++引入了引用的概念，使得代码更为简洁：（这两个函数还构成了函数重载哦）

void Swap(int& a, int& b)
{
    int tmp = a;
    a = b;
    b = tmp;
}

并且引用避免了直接操作指针和解引用的繁琐性，调用时也更加直观，如下所示：

Swap(a, b);

虽然这个例子中看似只是减少了取地址的操作，但引用的使用远不止于此。可能你这里会有点懵圈，但没关系，接下来我们将详细探讨引用。

注意：本篇博客中的代码均基于包含头文件 <iostream> 并在使用命名空间 std 的前提下编写。

概念

引用不是新定义一个变量，而是给已存在的变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。比如在外面别人以你的名字来称呼你，而在家中亲人以你的小名称呼你。

用法：类型& 名字 = 引用的变量(对象)名字；

举个例子：

int main()
{
    int a = 10;
    int& b = a; // b 就是 a 的引用，也就是 a 的别名

    return 0;
}

这样就定义了一个引用。

int main()
{
    int a = 10;
    int& b = a;
    cout << &a << endl; // cout 会自动识别数据类型并输出
    cout << &b << endl;

    b++;
    cout << a << endl; // a 的值变成了 11

    return 0;
}

程序运行后，可以发现 a 和 b 的地址相同，证实了它们共用同一块内存空间，进一步证明了编译器不会为引用变量单独分配内存。因此我们改变 b 的值其实就是改变 a 的值。

引用特性

int main()
{
    int& b; // 报错
    int* p; // 可以

    return 0;
}

在 C++ 中，引用在定义时必须进行初始化，而指针则允许延迟初始化，尽管这并不被推荐。

int main()
{
    int a = 1;
    int& b = a; // b 是 a 的别名
    int& c = a; // c 也是 a 的别名
    int& d = b; // b 也可以有别名，也就是说给别名取别名也是可以的
    // 这四个变量用的都是同一块内存空间

    return 0;
}

一个变量可以有多个引用，同时也可以为引用取别名。

int main()
{
    int a = 1;
    int& b = a;
    int c = 2;
    b = c; // 这里并不是改变引用的指向，而是把 c 的值赋值给 b，而 b 就是 a
    cout << a << endl; // 所以 a 的值变成了 2

    int* p = &a;
    p = &c; // 而指针是可以改变指向的对象的

    return 0;
}

引用在被初始化后不能改变其引用的对象，也就是不能改变引用的指向。以变量 a 被引用为例，一旦变量 b 引用了 a，就无法改变 b 引用的对象。与指针不同，指针可以灵活地改变指向的对象，因此在某些情境下，指针仍然是不可或缺的。例如，在数据结构中的链表结构，如果用引用替代结构体中的 next 指针，由于引用不能改变指向，插入新节点时无法将新节点链接到原链表中，试图强行改变引用会导致原节点的丢失。

常引用

int main()
{
    const int a = 10;
    int& b = a; // 报错
    const int& b = a; // OK!!

    return 0;
}

在这段代码中，变量 a 被 const 修饰后变成了常量，也就意味着 a 的值是无法被修改的，这时候如果让 b 引用 a，那么 b 就具有修改 a 的权限，这就出现了权限的放大，显然是不合理的。为了解决这个问题，我们可以将 b 也用 const 修饰，这样 b 也变为常量，实现了权限的平移。在C语言中，被 const 修饰的变量具有常属性，不能修改，但本质还是变量。而在C++中，被 const 修饰的变量则彻底成为常量。

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

    return 0;
}

在这里，通过 const 修饰 b，成功限制了通过 b 来修改 a 的值，实现了权限的缩小。这个过程可以类比于 const 修饰指针，可以限制指针的指向，或者限制通过指针来修改指向对象的值。

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

    return 0;
}

同样道理，这里的 10 是一个常量，因此在引用它时应该使用 const 进行修饰。

int main()
{
    int a = 1;
    double& b = a; // 报错

    return 0;
}

这里报错的原因也是与权限的放大有关。让我们首先回顾一下在 C 语言中学到的隐式类型转换。

int main()
{
    int a = 1;
    double b = a;

    return 0;
}

由于 a 和 b 的类型不同，将 a 赋值给 b 时发生了隐式类型转换。在这个过程中并未改变变量 a 的类型，而是创建了一个类型与 b 相同的临时变量来接收 a 的值，然后将这个值赋给了 b。值得注意的是，这个临时变量具有常属性，因此不能被修改。该过程可通过下图表示：

【C++】引用详解,c++,开发语言因此，当执行 double& b = a; 时，实际上相当于 double& b = tmp; 这引发了权限的放大，因此我们只需使用 const 来修饰该引用即可。由此可见，在定义引用时，最好让引用变量的类型和其引用的对象的类型相同，否则需要使用 const 进行修饰，这样会造成无法通过引用变量来修改对象的值。需要注意的是，在发生类型转换时，都会涉及一个具有常属性的临时变量。

下面我们再来看几个涉及临时变量的例子：

int x = 0;
size_t y = 1;
if (x > y)
{
    // ...
}

在这个比较中，由于 x 的类型为 int，而 y 的类型为 size_t，所以会发生类型提升，将 x 赋值给一个临时变量，并且其类型与 y 一致。因此在比较时，实际上是比较了两个相同类型的值。需要注意的是，在这种情况下，如果 x 的值为负数，可能会发生符号扩展。因为在将有符号整数 int 提升为无符号整数 size_t 时，负数会变成一个非常大的正数，这可能会影响比较的结果。

int* ptr = (int*)i;

强制类型转换也是如此，i 的类型并没有发生变换，只是借助一个类型为 int* 的临时变量给 ptr 赋值。

int i = 10000;
char ch = i;

在这个例子中，由于 i 的值为 10000，其范围超过了 char 类型的表示范围，发生了截断。在这种情况下，会创建一个类型为 char 的临时变量，将 i 的值截断并赋给 ch。

引用的价值

引用的价值主要在于做参数和做返回值。首先，引用作为函数参数时，可以直接修改传递的实参，同时提高了传参的效率。其次，引用作为函数返回值时，可以直接修改返回的对象，并且在传递返回值的过程中提高了效率。接下来，我们将逐一介绍这两种用法。

做参数

我们在前言中改写的 Swap 函数就是引用做参数，接下来看一下引用在单向链表结构中的应用：

typedef struct SListNode
{
	struct SListNode* next;
	int val;
}SListNode;

void SListPushBack(SListNode** pphead, int val)
{
	if (*pphead == NULL)
	{
		// ... 
		// *pphead = newnode;
	}
	else
	{
		// 找尾，链接newnode
		// tail->next = newnode;
	}
}

我们知道在单向链表中涉及到头节点的修改，因此我们需要传入二级结构体指针。但是我们学习了引用之后就可以简化点了：

typedef struct SListNode
{
	struct SListNode* next;
	int val;
}SListNode, * PSListNode;

// PSListNode 就是节点指针类型
// SListNode* 等价于 PSListNode

// 这里 phead 是传入的 头节点指针 的别名
void SListPushBack(PSListNode& phead, int val)
{
	if (phead == NULL)
	{
		// ... 
		// phead = newnode;
	}
	else
	{
		// 找尾，链接newnode
		// tail->next = newnode;
	}
}

由于 phead 是头节点的引用，所以修改 phead 其实就是修改头节点。

引用作为函数参数有助于提升效率。因为函数的形参是实参的一份临时拷贝，因此传递引用与传递指针一样，都可以避免拷贝对象这一操作。

做返回值

首先来看普通的传值返回：

int Count()
{
	int n = 0;
	n++;
	
	return n;
}

这里返回的是局部变量 n 的拷贝。在函数栈帧销毁前，如果要返回的值比较小，编译器可能会将其存储在寄存器中。然而，对于较大的对象，可能会使用堆栈或寄存器之间的其他内存空间，例如在两个栈帧之间。这种传值返回的方式可能会导致效率下降，特别是对于大型对象而言。

下面我们看一下传引用返回：

int& Count()
{
	int n = 0;
	n++;

	return n;
	// 这里返回的是n的别名，相当于n
}

int main()
{
	int ret = Count(); // 把 n 这块内存空间的值赋值给 ret
	cout << ret << endl;

	return 0;
}

在vs2019下，程序运行后的结果是 1，然而这是由于该编译器没有及时清理销毁的函数栈帧空间的缘故。这段代码存在悬空引用的问题。返回类型声明为 int&，表示返回一个整数的引用，但函数内部的局部变量 n 在函数结束后会被销毁，导致返回的引用指向一个不再有效的内存位置。尽管某些编译器可能未能检测到这种错误，但这种行为是不安全的，可能导致未定义的行为，如这段程序的结果理应是随机值。为避免悬空引用问题，应该避免返回对局部变量的引用。

再来看一个有趣的例子，同样是返回对局部变量的引用：

int& Add(int a, int b)
{
    int n = a + b;
    return n;
}

int main()
{
    int& ret = Add(1, 2);
    cout << "Add(1, 2) = " << ret << endl;
    Add(2, 3);
    cout << "Add(1, 2) = " << ret << endl;

    return 0;
}

这段代码中的 ret 是引用，实际上它是指向函数 Add 中局部变量 n 那块空间，但由于 n 是在函数栈上分配的，其生命周期在函数调用结束时就结束了。因此，ret 变成了一个悬挂引用，指向已经释放的内存。这会导致未定义行为，因为在第二次调用 Add 时，编译器可能会复用第一次调用时的栈帧，就是说使用第一次函数调用时开辟的变量 n 那块空间，导致 ret 的值被修改为 5 。值得注意的是，这里的结果可能是由于编译器优化策略导致的，也就是vs2019没有及时清理销毁的栈帧空间。实际结果应该是不确定的随机值。

下面通过一个例子帮助大家更好地理解函数栈帧的复用：

void func()
{
    int a = 0;
    cout << &a << endl;
}

int main()
{
    func();
    func();

    return 0;
}

观察到两次调用该函数后，打印的局部变量 a 的地址是相同的，这证实了函数栈帧空间可以复用。在函数执行完成后，函数的栈帧空间被释放，但由于编译器的优化，第二次调用函数时可以复用第一次调用时的栈帧，因此局部变量 a 的地址保持一致。

总结一下：
函数运行时栈的分配和释放：在函数运行时，系统会为该函数分配独立的栈空间，用于存储函数的形参、局部变量以及一些寄存器信息等。这确保了函数之间的独立性，每个函数都有自己的栈帧。当函数执行结束后，该函数对应的栈空间会被系统回收，这意味着该栈帧中的内存被标记为可用，但并不是立即被清空。
内存回收但内存仍在：空间被回收指该块栈空间暂时不能使用，但是内存还在。比如:在酒店开了一间房间，时间到了之后要办理退房手续，但是这个房间本身还在，不是说退房后这个房间就没有了。

如果返回的对象是在函数作用域内创建的，它的生命周期将在函数执行结束时终止。在这种情况下，使用引用返回可能导致未定义的行为，因为引用将指向已经被销毁的内存。因此，在这种情况下，引用作为返回值是没有意义的，并可能导致程序错误，得到的结果取决于编译器是否及时清理栈帧。相反，如果返回值是存放在静态区或堆区的（通过动态内存分配），那么对象的生命周期不受函数作用域的限制。在这种情况下，引用作为返回值是安全的，并且可以提升效率。

int& Add(int a, int b)
{
    static int c = a + b;
    return c;
}

由于变量 c 被 static 修饰，因此它是静态局部变量，出作用域不会销毁，这时候返回对 c 的引用是安全的，需要注意的是，静态局部变量只在第一次调用函数时进行初始化，后续调用函数时 c 的值不会改变。值得强调的是，当我们在函数中定义一个静态局部变量时，它实际上只是一个声明，真正的内存空间分配和初始化则发生在第一次调用该函数时。如果程序在运行时没有执行包含该静态局部变量的函数，系统将不会为该变量分配内存空间，也不会执行初始化操作。

int& Add(int a, int b)
{
    static int c;
    c = a + b;

    return c;
}

稍加改动就可以实现返回值随着参数的变化而变化了。

相对于传值返回，在处理较大的返回值对象时，传引用返回通常能够提高效率。这是因为传值返回涉及对返回对象的临时拷贝，而传引用允许直接操作原对象，避免了不必要的复制操作，从而提升了性能。此外，传引用返回在一些需要修改返回对象的场景中非常实用，例如顺序表中的数据修改操作。

引用与指针

底层实现

从语法上来看引用变量就是一个别名，没有独立空间，和它引用的对象共用同一块空间。这一点我们在前面的例子中通过打印地址也能看到确实是一样的。但是从底层来看，引用的实现方式和指针是一样的，也就是说它其实是有开空间的。

int main()
{
	int a = 10;
	int* p = &a;
	int& ref = a;

	return 0;
}

这段代码的汇编代码如下图所示：

【C++】引用详解,c++,开发语言

可以看到都是有取地址这个指令的，因此从底层来看引用是按照指针方式来实现的。但平时我们使用时，就当引用是没有独立空间的即可。

不同之处

1. 引用概念上是定义一个变量的别名，而指针则是存储一个变量的地址。
2. 引用在定义时必须初始化，而指针则没有这个要求，但需提防野指针问题。
3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体
4. 没有NULL引用，但有NULL指针
5. 在 sizeof 中含义不同：引用的大小为引用类型的大小，而指针的大小始终是地址空间所占字节个数(32 位平台下通常是4个字节，64 位平台下通常是8个字节)
6. 引用自加会使引用的实体增加1，指针自加会使指针向后偏移一个类型的大小
7. 有多级指针，但是没有多级引用
8. 访问实体方式不同：指针需要显式解引用，而引用的访问由编译器自动处理
9. 相对而言，引用的使用更安全，前提是不要试图返回已销毁对象的引用。