1. 引用的概念
引用不是定义一个新的变量，而是给已有的变量取一个别名，编译器不会给引用变量开辟新的内存空间，而是和它引用的变量共用同一块内存空间
使用规则：类型& 别名 = 引用实体
举个栗子：
我们发现，对于变量a，我们用ra当作他的别名，然后我们又定义了一个引用变量x，他的引用实体是ra，这说明了同一变量，可以有多个引用。然后我们注意右边的调试窗口，可以发现a，ra，x，y的地址都是相同的，所以他们共用同一块内存空间。
那么，我们要怎么使用呢？举个栗子，我们之前学习C语言的时候写过一个Swap函数
void swap(int* x, int* y)
{
int tmp = *x;
*x = *y;
*y = tmp;
}
这里需要传地址给Swap函数，才能实现交换变量值的功能，但是如果使用引用，就可以省略解引用的操作。
void Swap(int& x, int& y)
{
int tmp = x;
x = y;
y = tmp;
}
注意：引用类型必须和引用实体是同种类型的，否则会报错，在VS2022环境下报如下错误：error C2440: “初始化”: 无法从“int”转换为“char &”
2. 引用的特性
- 引用在定义时必须初始化
- 一个变量可以有多个引用
- 引用一旦引用一个实体，再不能引用其他实体
对于特性1：
对于特性二：在图一中已经很好的体现出来。
对于特性三：假设我们想改变引用的实体，我们应该会使用类似与“ra = b”这种语句，但是如下图，我们看到第31行代码并没有报错，那么是不是表示引用变量引用的实体是可以改变的呢？注意右边的监视窗口，ra的地址和b的地址并不相同，这说明ra不是b的引用，ra还是a的引用，所以第31行的语句是改变a的值，而不是改变ra的引用。
3. 常引用
常引用就是在定义引用变量时加上const修饰。
我们看下面一段代码
void TestConstRef()
{
const int a = 10;
int& ra = a;
const int& ra = a;
int& b = 10;
const int& b = 10;
double d = 12.34;
int& rd = d;
const int& rd = d;
}
这段代码有什么问题呢？
运行之后发现，第40行因为我们定义的变量a是用const修饰的，而ra是没有用const修饰的，是可以更改的，这样的话，引用变量的权限还变大了，这是不合理的。第41行中，ra的类型和a的类型相同，都是const int类型，所以不会报错。对于第42行，变量b引用的是一个常量，是不可修改的，但是b本身的权限是可修改的，也造成了权限的扩大，所以报错。后面的第45行也是同理，因此我们得出结论：指针和引用赋值中，权限可以缩小，可以平移，但是不能扩大。
那么，常引用有什么使用场景呢？我们看下面一个例子
void Func(int& x)//假设传一个参数
{
//做一些不需要修改传入的值的操作
//...
}
int main()
{
int a = 10;
int& ra = a;
const int& rra = ra;
Func(a);
Func(ra);
Func(rra);//const修饰的参数，传参的时候会出现权限放大的问题
return 0;
}
对于这种情况，我们传一个const修饰的参数，就会出现问题，因此，在这个地方我们定义函数时应该使用"const int& x"来代替"int& x"。
const引用还有一个点需要注意，我们看下面一段代码
int main()
{
const int& b = 10;
double d = 12.34;
int i = d;// 这句代码有问题吗？
int& ri = d;// 这句代码有问题吗？
return 0;
}
答案是第一句没有问题，第二句有问题。为什么呢？因为在第二句中，ri的类型时int&，但是d的类型是double，所以在指定引用实体的时候，指定的并不是d的空间，即ri并不是d的别名，而是在转换之前开辟了一块临时变量存储int类型的数据，这个数据是d中存放的值转换而来的，而语法规定：临时变量具有常性，可以理解为用const修饰过，所以这句代码就造成了权限扩大，所以这句代码我们应该改为"const int& ri = d"
注意：强转，截断，提升都会产生临时变量。
4. 使用场景
做参数
1. 输出型参数
2. 普通参数
做缺省参数
到这里，就会有一个疑问，引用可以做缺省参数吗？
void Func(int& x = 10)
{
cout << x << endl;
}
int main()
{
Func();
return 0;
}
我们看上面一段代码，有没有什么问题，能否正常运行？
不能，会报错
这是因为常引用，权限不能扩大只能缩小或平移，所以把函数声明中参数类型改为const int& x = 10即可。
做返回值
我们看下面一段代码
int& Count()
{
static int n = 0;
n++;
// ...
return n;
}
int main()
{
int ret = Count();
cout << ret << endl;
return 0;
}
这段代码运行的结果是输出1，那么如果Count函数中没有static，会发生什么呢？
首先，我们要明确一点，static修饰的作用是将n放在了静态区，也就是说出了函数作用域不会被销毁，
P.S.空间销毁意味着什么？
空间销毁后空间还是在的，只是使用权不是我们的了，我们存的数据不再被保护。我们可以去进行访问，只是读写的数据是不确定的。
如果把static去掉，那么n就会存在函数Count的栈帧里面，我们当Count函数调用结束之后，n的空间就会被销毁。
这里再补充一点：函数在传值返回的时候，会生成一个临时变量，将返回值拷贝到这个临时变量中，然后再拷贝给我们需要赋值的变量。对于大小较小的值(类似于一个整形或者是地址)这个临时变量一般在寄存器中，如下图的汇编代码，但是对于较大的返回类型，比如一个结构，会提前在函数调用前在调用该函数的函数栈帧里创建一块空间，然后拷贝到块空间里面。
图八
OK，现在我们继续讨论刚刚n的问题，如果我们使用传引用返回的话，我们可以理解成创建了一个临时变量，但是这个临时变量是不开辟空间的，也就是n的别名，但是在函数调用结束以后，n的空间已经是销毁的，所以传回来的值就是不确定的。如图八，就可以证明，如果在调用结束以后，我们又调用了其他函数，那么这个位置的值就是被更改过的（其实最后输出的那个100本身是随机值，但是在VS2022中，这里被优化了，所以表现出来的值还是100）。
结论：如果函数的返回对象在函数调用完毕之后，空间是没有返回给操作系统的，比如是在静态区创建的，就可以使用传引用返回，否则就不能使用传引用返回。
传引用返回的例子
在我们之前用C实现顺序表的时候实现了一个Modify的功能，用于修改顺序表中的值，但是，实现的具有局限性，如果我们现在的要求是将顺序表中所有的偶数值变成原来的二倍，这时候用Modify就非常复杂，但是，如果我们使用传引用返回，就可以做这样的优化
int SeqListSize(SeqList* ps)
{
assert(ps);
return ps->size;
}
SLDataType& SeqListAt(SeqList* ps, size_t pos)
{
assert(ps);
assert(pos < ps->size);
return ps->a[pos];
}
通过这两个函数，我们就可以直接访问到顺序表中的数据，如下图：
5. 传值与传引用的比较
以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直
接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效
率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低
我们看下面两段代码
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 < 1000000; ++i)
TestFunc1(a);
size_t end1 = clock();
// 以引用作为函数参数
size_t begin2 = clock();
for (size_t i = 0; i < 1000000; ++i)
TestFunc2(a);
size_t end2 = clock();
// 分别计算两个函数运行结束后的时间
cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
}
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;
}
这段代码就可以比较出来两种传递的的效率，我们运行后就可以看到
通过上述两段代码的比较，发现传值和指针在作为传参以及返回值类型上效率相差很大。
6. 引用与指针的区别
在语法上，引用就是一个别名，创建时不开辟空间，和引用实体共用一块空间
在底层上，引用是通过指针的方式实现的，所以是开辟空间的
int main()
{
int a = 10;
int& ra = a;
ra = 20;
int* pa = &a;
*pa = 20;
return 0;
}
调试这段代码，我们查看它的汇编代码会发现
他们的汇编代码是相同的，也就证明引用的底层是用指针实现的。
引用和指针的不同点:
- 引用概念上定义一个变量的别名，指针存储一个变量地址。
- 引用在定义时必须初始化，指针没有要求
- 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何
一个同类型实体- 没有NULL引用，但有NULL指针
- 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32
位平台下占4个字节)- 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
- 有多级指针，但是没有多级引用
- 访问实体方式不同，指针需要显式解引用，引用编译器自己处理
- 引用比指针使用起来相对更安全