前言

在上一次的内容中我们讲解了C++语言函数重载的内容，还不清楚的朋友可以去看看我的上一篇博客(https://blog.csdn.net/be_a_struggler/article/details/125880093)本次我们将会继续讲解C++的引用部分，非常重要，一起来看看吧。

引用

1.引用的概念

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。(简单的理解就是我们给变量取了一个外号，本质上还是他)
语法： 类型&引用变量名(对象名) = 引用实体；
注意：
1. 这里的&并不是取地址的意思，不要混淆。
2. 引用类型必须和引用实体是同种类型的。

通过上图大家就能对引用有一个更好地理解了，a与ra的地址是相同的，最后输出的数值也相同，ra就是a，a就是ra。

2.引用特性

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

3.常引用

在这里就涉及到了权限被放大和权限被缩小的问题。

	//权限不能放大
	const int b = 5;
	//int& rb = b;   //该语句编译时会出错，权限被放大，b为常量，
	//执行该语句之后可以理解为b变成了int类型(可读可改，权限被放大)，这是不允许的
	const int& rb = b;

	//int& c = 10;   //该语句编译时会出错，与上述问题一样，10为常量(权限被放大)
	const int& c = 10;

	double d = 15.62;
	int a = d;
	//int& rd = d;   //该语句编译时会出错,d是double类型，rd是int，
	// d要赋值给rd的时候要生成一个临时变量，临时变量具有常性，在这里权限被放大
	const int& rd = d;

	//权限可以缩小
	int a = 10;
	const int& ra = a;//a从可读可写变为了只可读，权限被缩小，这是允许的。
	
	const int& x = 10;//这个也是支持的x为一个常量的别名。 

通过这里的我们可以发现const具有很强的接受度。

4.使用场景

1.做参数
1.输出型参数(我将一个数据传给函数，然后再得到一个改变了的值。例如Swap(交换函数))

void Swap(int& left,int& right)
{
	int tmp = left;
	left = right;
	right = tmp;
}
//这里其实引用与指针的作用差不多，但是引用不需要解引用，看起来更容易理解一些

2.大对象传参提高效率

#include<iostream>
using namespace std;
#include <time.h>
struct A { int a[10000]; };
void TestFunc1(A a) {}
void TestFunc2(A& a) {}
void TestRefAndValue()
{
	A a;
	// 以值作为函数参数
	size_t begin1 = clock();
	for (size_t i = 0; i < 10000; ++i)
		TestFunc1(a);
	size_t end1 = clock();
	// 以引用作为函数参数
	size_t begin2 = clock();
	for (size_t i = 0; i < 10000; ++i)
		TestFunc2(a);
	size_t end2 = clock();
	// 分别计算两个函数运行结束后的时间
	cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
	cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
}

int main()
{
	TestRefAndValue();
	return 0;
}

在这里通过对比我们可以发现当一个对象内数据很多时，引用做参数就会节省大量的时间。

在讲述下面问题的时候我们先来看一下关于函数返回值的知识点，先观察上图。

我们可以看出这是一个简单的传值返回，但是其过程是值得我们探究的，Count1函数中的n为局部变量，在Count1的函数栈帧中，调用完函数就会被销毁，此时我们可以说此处返回的并不是n，而是n的一份临时拷贝，然后我们再将临时拷贝的值传给ret。
再来观察第二个函数Count2，这里的n用static修饰后就会变为一个静态全局变量，在静态区保存，即使函数的栈帧被销毁后也不会将n变量销毁，那么其实在这里我们是可以直接传n的值的，但是编译器的操作还是会形成一份临时拷贝，然后将其值传给ret，为什么会这样操作呢？？
其实与我们前面讲的那种传值返回有关系，因为编译器并不像我们人一样聪明，他也并不会去区分这两个东西，只要是传值调用都会形成一份临时拷贝。
有了这个做铺垫以后我们再来看看一看引用作返回对象。
2.做返回值

1.修改返回对象：当我们使用了引用返回时，加入我们想修改上图中n的值，我们只需要在外面进行就可以了。

int& Count2()
{
	static int n = 0;
	n++;
	return n;
}
int main()
{
	Count2()++;//这里可以直接修改n的值
	return 0;
}

2.大对象返回会提高效率

#include<iostream>
using namespace std;
#include <time.h>
struct A { int a[10000]; };
A a;
// 值返回
A TestFunc1() { return a; }
// 引用返回
A& TestFunc2() { return a; }
void TestReturnByRefOrValue()
{
	// 以值作为函数的返回值类型
	size_t begin1 = clock();
	for (size_t i = 0; i < 100000; ++i)
		TestFunc1();
	size_t end1 = clock();
	// 以引用作为函数的返回值类型
	size_t begin2 = clock();
	for (size_t i = 0; i < 100000; ++i)
		TestFunc2();
	size_t end2 = clock();
	// 计算两个函数运算完成之后的时间
	cout << "TestFunc1 time:" << end1 - begin1 << endl;
	cout << "TestFunc2 time:" << end2 - begin2 << endl;
}

int main()
{
	TestReturnByRefOrValue();
	return 0;
}

通过运行结果我们可以看出二者效率上的差距还是很大的。

5.引用和指针的区别

在语法概念上 引用就是一个别名，没有独立空间，和其引用实体共用一块空间。
在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。

下面是引用和指针的汇编代码对比

引用和指针的不同点：

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

总结

本次我们主要讲了引用这一块的内容，引用其实理解起来还是有一定的难度的，大家配合着编译器多试一试，可以帮助我们更好地去理解，往后会持续更新关于C++的内容及知识，希望大家能够点赞，收藏，关注支持博主。
当如果文章中有不对的地方欢迎大家评论指正，让我们在学习的道路上一起进步。