1.概念
引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空
间，它和它引用的变量共用同一块内存空间
类型& 引用变量名(对象名) = 引用实体；
而引用类型必然要与引用实体的类型一致。
void TestRef()
{
int a = 10;
int& ra = a;
printf("%p\n", &a);
printf("%p\n", &ra);
}
2.引用特性
1.不同于指针，不初始化也不会报错，引用在定义时必须初始化
int& ra = a;//right
int& ra;//error2. 一个变量可以有多个引用
int a=0;
int& b=a;
int& c=a;由于引用只是引用实体的一个别名，因此我们也可以这样使用
int a=0;
int& b=a;
int& c=b;3. 引用一旦引用一个实体，再不能引用其他实体。
int a=0;
int b=1;
int& c=a;
c=b;
例如上面的代码，c=b的作用并不是让c变为b的别名，而是将b的值赋给c，也就是a
3 .常引用
int a=10;
const int& ra=a;类似于const常量，const修饰常引用后，我们无法做到改变ra的值来改变a的值，而只能通过a来进行改变。
const int a=10;
int& ra=a;而这段代码，本身a不能修改，如果直接用ra引用，会导致权限放大，是不可以的
而权限不变和权限缩小都是没有问题的
const int b=10;
const int& rb=b;
int c=10;
const int& rc=c;我们再来看一下下面的代码
double a=1.23
int b=a;
int& c=a;
const int& d=a;经过测试，我们可以得知，b和d是可以这样使用的,而c不可以，这是因为，在进行隐式类型转换或整形提升时，需要创建一个临时变量来存储，这样，c和d其实就是作为这个临时变量的引用，而临时变量是无法被改变的，所以我们需要进行常引用。
而同样，由于临时变量具有常性
int x1=1;
int x2=2;
int& x=x1+x2;这样的代码也是不可行的，依然需要使用常引用。
而在后面会讲到的引用传参中，如果不需要改变参数，建议也使用常引用
4. 引用的使用场景
(1).引用作参数
void Swap(int left, int right)
{
int temp = left;
left = right;
right = temp;
}
void Swap(int* left, int* right)
{
int temp = *left;
*left = *right;
*right = temp;
}
void Swap(int& left, int& right)
{
int temp = left;
left = right;
right = temp;
}例如一个简单的交换函数，在c语言的学习中，我们知道，传值调用参数只是一个拷贝，无法完成实参的交换，因此我们选用传址调用，通过指针来完成交换。
而我们也可以进行传引用，这是，left与right都是实参的别名，对形参进行交换时，其实也就是对实参进行交换。
我们在这里插入一个点，这三个函数是否构成函数重载呢？其实是构成的，因为它们的参数类型是不同的，但是，由于传引用与传值的实参都是相同的，所以即使能构成函数重载，在使用时也会出现问题。
单从上面，我们似乎还感知不到引用的优势，我们可以看一下我们在数据结构中所学到的链表
void SListPushBack(SLTNode** pphead, SLTDateType x)
{
SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
if (newnode == NULL)
{
exit(-1);
}
newnode->data = x;
newnode->next = NULL;
if (*pphead == NULL)//由于无哨兵位，若链表为空只需要赋值
{
*pphead = newnode;
}
else
{
SLTNode* tail = *pphead;
//找尾
while (tail->next != NULL)
{
tail = tail->next;
}
tail->next = newnode;
}
}就以尾插为例，许多同学可能在刚开始学习时无法理解参数中二级指针的含义
而本身我们需要传入的是以指针存储的头结点的地址，但在插入或删除中，头结点的位置可能会被改变，所以我们需要进行传址调用，这便是使用二级指针的原因。
而我们将传址调用改为传引用，同样能做到改变头结点的位置，同时也更容易去理解
void SListPushBack(SLTNode*& rphead, SLTDateType x)
{
SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
if (newnode == NULL)
{
exit(-1);
}
newnode->data = x;
newnode->next = NULL;
if (rphead == NULL)//由于无哨兵位，若链表为空只需要赋值
{
rphead = newnode;
}
else
{
SLTNode* tail = rphead;
//找尾
while (tail->next != NULL)
{
tail = tail->next;
}
tail->next = newnode;
}
}(2).引用作返回值
我们先来简单分析一下传值返回
int Add(int a, int b)
{
int c=a+b;
return c;
}
int main()
{
int add=Add(1,2);
return 0;
}
首先先开辟一块主函数的空间，紧接着去调用Add函数。而Add函数的空间内分别有三块空间存储a,b,c的值。而在传值返回中，返回的并不是c，而是c的一个临时变量。而Add这块空间便被销毁了
而临时变量较小时，会被存放在寄存器中，较大时，则会存放在调用Add函数的栈帧中
当我们转到反汇编时，可以看到，在return c中，临时变量的确时存储在eax这个寄存器之中的。
而当我们进行传引用返回时，返回的便不是c的拷贝的临时变量，而是c的引用
int& Add(int a, int b)
{
int c=a+b;
return c;
}
int main()
{
int add=Add(1,2);
return 0;
}而这样，会出现一些问题，例如非法访问。而由于编译器的不同，有些编译器中Add函数在调用过后会被销毁，这样会c为随机值，进而导致add变量为随机值。
例如我们在原代码的基础上做一些改变
int& Add(int a, int b)
{
int c = a + b;
return c;
}
int main()
{
int& add = Add(1, 2);
cout << add << endl;
Add(10, 20);
cout << add << endl;
return 0;
}这时，临时变量是c的引用，而add是临时变量的引用，因此add便是c的引用。
而当第二次调用Add函数是，Add函数所占的空间不变，因此会使c变为30，而add也一样
同样，若是Add函数调用过之后会被销毁，当c变量原来的地址被占用时，也会出现类似的问题。
当然，传引用返回也有好处，例如在内存中开辟一块空间存储一个较大的数组等，当我们使用传值返回时，需要进行拷贝，使用大量空间，而传引用返回就不需要进行拷贝，从而会使效率提升。同时，由于是在内存中开辟空间来存储数组，也不会发生非法访问的问题。
同样，引用传参也有效率提升这个优势。
5.引用传参和传返回值的优势
1.有些场景下会使效率提升（大对象+深拷贝，后面会讲）
2.有些场景下，形参的改变可以改变实参，引用返回可以改变返回对象（后面也会将讲）
6. 引用和指针的区别
1.在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。
2.引用在底层实现上实际是有空间的，因为引用是按照指针方式来实现的 3. 引用概念上定义一个变量的别名，指针存储一个变量地址。
4. 引用在定义时必须初始化，指针没有要求
5. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何
一个同类型实体
6. 没有NULL引用，但有NULL指针
7. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32
位平台下占4个字节)
8. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
9. 有多级指针，但是没有多级引用
10. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理
11. 引用比指针使用起来相对更安全
为什么说引用更加安全呢？举个简单的例子
void test1(int* p)
{
*p = 10;
}
void test2(int& r)
{
r = 10;
}这样的函数，在传参时，使用指针可能会发生许多人为的错误，例如空指针、野指针等。
test1(NULL);
test1(0);而使用引用并不会。
