【C++入门篇】学习C++就看这篇---＞引用超详解-CSDN博客

前言：

本篇文章是上篇博客的延续，继续讲述一些零碎的C++入门的知识点，今天我们用一篇博客来讲述一个C++里面比较重要的知识点：引用，和指针比较类似，希望通过本篇博客的学习，大家对引用的了解达到炉火纯青，希望大家有所收获。

在这里先补充一个知识点：

上篇博客我们学习了函数重载，但有一个问题就是，C++是兼容C的，但是我C想用C++的东西怎么办？我C是不支持函数重载的，因此有个extern "C"机制，就是在我们所用的函数前面加上 extern "C"，那么它的符号表里就会变成C语言那套机制，用函数名去对应函数，这样C语言就支持去用C++中的函数了，并且对于加入extern "C"的函数C++也会通过函数名找对应的函数。

一、引用

1.1 引用概念

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。就是你可以叫张三，也可以被别人叫小张。

如何使用？类型& 引用变量名(对象名) = 引用实体；注意：引用类型必须和引用实体是同种类型的

void Test()
{
    int a = 10;
    int& ra = a;//<====定义引用类型
}

1.2 引用特性

1. 引用在定义时必须初始化
2. 一个变量可以有多个引用
3. 引用一旦引用一个实体，再不能引用其他实体

int main()
{
	int a = 10;
	// int& b;   // 该条语句编译时会出错，就是因为没有初始化
				//没有初始化，我是谁的别名，编译器又不给我开辟空间，终是潦倒一人
	int& b = a;
	int& c = a;
	int e = 20;
	int& c = e;//会报错，我c怎么又是a的别名，又是e的别名，我到底是谁
	return 0;
}

注意事项：

void Test()
{   //1.
	const int a = 10;
	//int& ra = a;   // 该语句编译时会出错，原因：a是只读，ra的类型是int，就是可读可写的因而不行
	                 // 权限放大了，这是不允许的
    const int& ra = a;//正确用法

    //2.
    int c = 1;
    const int& e = c;//这是可以的，这是从可读可写到只读，涉及权限缩小是可以的
    //总结：引用取别名时，变量访问的权限可以缩小，不能放大

    //3.
	//int& b = 10;  // 该语句编译时会出错，b为常量
	const int& b = 10;//正确用法

    //4.
	double d = 12.34;
	//int& rd = d;  // 该语句编译时会出错，类型不同
	const int& rd = d;//正确用法，不过要注意这里并不是为d取了个别名叫做rd
                      //而是创建了一个新的空间名字叫做rd，即是赋值的关系
                      //类似于下面的隐式类型转换
    int i = 0;
    double di = i;//即重新开辟一个double类型的空间将i的值赋给di
}

事实上涉及权限缩小和放大的问题是适合于引用和指针，对于赋值是不适合的，相信你会感觉到，这根本的区别就是，我们两个变量名字是不是指向同一块空间，如果是同一块空间那么就要遵守上述权限的缩小放大的原则。
const int* cp1 = &a;
int* p1 = cp1;//这样就是不行的，属于权限放大，本来我就是只读，你怎么能可读可写

int* p2 = &c;
const int* cp2 = p2;//这是可以的，属于权限缩小

上述第四点如下所示：

1.3 使用场景

1️⃣ 做参数

我们C语言当中正常传参是一个什么样？是不是一般而言形参会另开辟一块空间啊，如下一段代码所示：

因为是另开辟的空间，因此正常的传值传递是不能改变函数外的值的，那我们要更改外面的值是怎么做的？是不是传地址啊，对传地址。

void Swap(int left, int right)
{
	int temp = left;
	left = right;
	right = temp;
}

引用做参数，就是正常的引用，不会另开辟空间的，即left与right就是实参的别名，因为是别名，即仍然是同一块空间，因此可以通过函数内的操作改变函数外的值，如下所示：

void Swap(int& left, int& right)
{
	int temp = left;
	left = right;
	right = temp;
}

2️⃣做返回值

传值返回解惑：相信大家会有疑惑，这和传值返回有什么区别？不清楚大家是否了解传值返回，问个问题，传值返回是仅仅将n的值返回吗？返回的是仅仅是n的空间的值吗？下面为大家解惑：

int Count()
{
	static int n = 0;
	n++;
	return n;
}
int main()
{
	const int& r1 = Count();
	return 0;
}

大家观察上述代码，你说r1的地址和n的地址一样不？那函数返回的是n怎么能不一样，错，就是不一样的，这是因为传值返回的时候建立了一个临时变量，即产生了一个临时空间存储这个n的值。见下：

补充知识：

大家写代码的时候可能会遇到下面的错误，也能看到上面我带了const，这就是因为C++规定了临时对象都具有常性，所谓常性就是指变量的值在初始化之后不能改变。

引用返回：上面解答了可能大家心中存在的疑惑，那引用返回是个什么样？是不是就类似于上面做参数那样，就不开辟这个临时变量的空间了，对，要证明这点，是不是只要r2与n的地址一样就证明了这一点，如下所述就是引用做返回值：

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

相信看到上述的代码，大家会注意到static，这个可能我们会不会猛然惊醒，是不是在哪见过🫣，对是C语言的，可能平常我们不常写大型的项目，用的不多，就相对陌生，事实上这是个很重要的知识点，望大家牢记，那它是什么呢？为什么在这个地方？

static是改变变量的生命周期的，它会把变量定义到静态区，达到和全局变量同等的生命周期。

为什么加到这个地方？我们先说不加的后果吧，见下面代码：
int& Count2()
{
	int n = 0;
	n++;
	return n;
}
int main()
{
	int& r2 = Count2();
	return 0;
}
我们都知道这样定义n是一个局部变量，出了Count2函数就销毁了，那我们引用个毛啊，这不就和指针一样了，造成野指针问题了，非法访问内存了嘛，所以怎样解决，就是加static，加了他就不是一个局部变量，出了这个函数，这个变量所属的空间依然是我们所能管控的范围。见下述验证：

嗯？你不是说非法访问吗？这怎么还是1，你骗我们，同志稍安勿躁，待我娓娓道来。一般而言我们操作系统是怎么删除的？你说把这块空间交给操作系统，它就立马给我们释放了吗？立马把这些数据就直接删除了？你要记住数据存储是在磁盘，它是很慢的，操作系统都是过一定时间才去交互的，所以操作系统删除数据一般是惰性删除，把对应描述这些空间的标志位置零，即是表示这块空间被释放，但是空间里的内容并不是就是清零。这些知识即将会在接下来Linux操作系统博客更新中体现，在这里我们了解到此即可。因此虽然这里Count2调用结束，并且将空间交还给操作系统，但是里面的内容并没有被清除，因而我们还是能访问到这个1，但是如果有新的变量或者新的什么东西需要占用空间时，那么存储结构就发生了变化，Count2之前所属的那部分存储空间就不一定保持完整，因而就有可能访问不到这个1了，因为有新的数据内容覆盖了。验证如下：

现在我们回到static，所以为了解决上述就用static将变量n不定义在栈区，定义到静态区，这样变量n就不会销毁，保持了原有的数据。验证如下：

嗯？你说的我听懂了，就是加了static它的空间就不释放，数据依然是可以访问的，但是这里你每次调用不都重新定义为0了，怎么还能是2呢？这里又有一个细节，就是只要static定义变量时定义一次之后不会再进行定义，所以第二次调用时代码会直接跳过static定义语句。那我想让它每次都从0开始怎么办？如下办：
static int n = 0;
	n = 0;
	n++;
	return n;
这样就可以解决。

总结一下：

如果函数返回时，出了函数作用域，如果返回对象还在(还没还给系统)，则可以使用引用返回，如果已经还给系统了，则必须使用传值返回。

1.4 传值、传引用效率比较

以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低，前面我们已经画图理解，不再赘述。我们可以通过下面两段代码进行验证：

#include<stdio.h>
#include<iostream>
#include<stdlib.h>
#include <time.h>

using namespace std;

struct A { int a[10000]; };
void TestFunc1(A a) {}
void TestFunc2(A& a) {}
void main()
{
	A a;
	// 以值作为函数参数
	size_t begin1 = clock();
	for (size_t i = 0; i < 100000; ++i)
		TestFunc1(a);
	size_t end1 = clock();


	// 以引用作为函数参数
	size_t begin2 = clock();
	for (size_t i = 0; i < 100000; ++i)
		TestFunc2(a);
	size_t end2 = clock();


	// 分别计算两个函数运行结束后的时间
	cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
	cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
}

作为返回值时两者的对比亦是如此，不在详述。

1.5 引用和指针的区别

1️⃣语法概念上

引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。

2️⃣底层实现上

实际是有空间的，因为引用是按照指针方式来实现的，汇编代码就是一样的

🚩引用和指针的区别（重要）:

1. 引用概念上定义一个变量的别名，指针存储一个变量地址。

2. 引用在定义时必须初始化，指针没有要求

3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体

4. 没有NULL引用，但有NULL指针

5. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32 位平台下占4个字节)

6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小

7. 有多级指针，但是没有多级引用

8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理

9. 引用比指针使用起来相对更安全

二、总结

本篇博客我们总结学习了以下知识点：C++引用是为变量创建别名，共享内存空间，须初始化且不可更改引用对象。关键特性：必须初始化、支持多别名、类型一致，const引用可绑定常量或隐式转换类型（权限不能放大）。应用场景：作函数参数（避免拷贝，提升效率）和返回值（需确保对象生命周期，避免悬空引用）。与指针区别：引用无独立内存、更安全（无空引用、不可重定向）、语法简洁（自动解引用）。效率上，引用传参/返回优于值传递，减少拷贝开销。注意函数返回局部变量时，引用会导致未定义行为，而指针仍需手动管理内存。引用底层通过指针实现，但封装了操作，限制更多，安全性更高。希望大家有所收获!