概念
引用不是新定义一个变量，而是给以存在的变量取一个别名，编译器不会为引用变量开辟空间，它的它的引用的变量公用同一块空间。
给大家举个形象的例子：
你生下来的时候父母为你取名叫林俊杰，为了叫的亲切，父母在家叫你小杰，在学校里根据你的某些特质，同学又叫你老狗，这里林俊杰、小杰、老狗三个名字指的都是同一个人。
书写格式：
int a = 10;
int& ra = a; <==定义引用类型
这里的引用和取地址用了同一个符号 “&”；
只不过之前的取地址，“&” 是放在变量名前，如：&a就表示a的地址；
这里的引用，“&” 放在类型名之后，如：int& a，表示一个变量 a ,它的类型是一个 int型变量的别名。
引用的特性
-
引用在定义时必须进行初始化
也就是说在一个引用类型产生时，必须写明它是哪个变量的别名。
如下的方式是不可以的：
int a = 10;
int& ra;
ra = a; -
一个变量可以有多个引用
如下：int a = 10;
int& ra1 = a;
int& ra2 = a;
int& rra = ra1;这里的
ra1、ra2、rra都是a的别名，对它们操作也就是对a操作。 -
引用一旦引用了实体，再不能引用其他实体
int a = 10;
int b = 20;
int& ra1 = a;
ra1 = b;
以上代码可以正常运行，最后一行的解释只能是，把b变量表示的20 赋值给a变量，此时ra1还是a的别名。
常引用
const int a = 10;
int& ra = a; //该语句会报编译错误
const int a = 10;
const int& ra = 10; //正常运行
int a = 10;
const int& ra = a; //正常运行
可以发现修饰原则：
对于引用变量，权限只能缩小，不能放大
任意变量，只要有const修饰，那么我们的使用权限就变为了只读，
而不加const,如：int a;就是可读可写的，
也就是说，如果原本是只读的，那么它的别名不可将权限放大，只能是const int
如果原本是可读可写，那它的别名可以权限不变，也是int;也可以缩小权限,变为const int
const使用场景
在用引用做函数参数的时候，我建议大家，如果这个参数在函数中作用只是读取，那么就尽量加上const。
这里作用有二：
-
如果我们不小心把这个值改了，那么编译阶段就会在这里显示错误，降低了错误的检查成本。
-
如果说前一条还不足有说服力，那么我可以告诉大家，有些情况我们是避免不了要传一个常量进去的：
看下面两段代码：
double d = 10.5;
int i = d; //正常发生截断
double d = 10.5;
int& i = d; //报错
分析一下：
-
第一段代码是一个普通的拷贝，只不过在拷贝过程要发生一个隐式类型转换，编译器会再申请一个临时变量，对 double 型
d的整数部分‘10’进行提取，放在临时变量1中，然后把这块空间的内容拷贝到整型‘i’中。 -
第二段代码前本部分的操作与第一段相同，直到放在临时变量中，这时要对这个临时变量进行取别名，然而这个临时变量是具有常性的，也就是说我们引用了一个常量，然而我们用的是int&,增加了权限，因此报错。
更改：
double d = 10.5;
const int& i = d;
这时就可以正常编过了。
-
这只是一个例子，这种不可控的情况还有很多，所以，如果可以，大家尽量加上const.
引用的使用场景
做参数
void Swap(int& x, int& y)
{
int tmp = x;
x = y;
y = tmp;
}
void Swap(double& x, double& y)
{
double tmp = x;
x = y;
y = tmp;
}
int main()
{
int a = 0, b = 1;
Swap(a, b);
double c = 1.1, d = 2.2;
Swap(c, d);
return 0;
}
这里的Swap函数参数可以是指针，但用引用不论是传参还是写函数过程，都更加直观。
引用作用：
- 减少拷贝
我们说，如果要传址传参的时候，把指针改为引用更方便、更直观；
但是这里要说，即使是传值传参也尽量用引用，原因是可以减少拷贝，增加效率。
下面，我们把一个40000字节的结构体作为传参对象，分别传10000遍，验证传值和引用的效率区别。
#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;
}
-
做输出型参数
什么是输出型参数？
案例一：
大家如果在LeetCode用C语言刷过题，一定见过如下的参数
这里的
returnSize和returnColumnSizes并非要传什么数据进来，而是需要你对这两个变量进行赋值，从而实现值的返回，如这里returnSize就是要返回数组的大小。比如创建的数组大小是10，那么在函数内
*returnSize = 10；就可。那么如果用引用呢？
需要在参数列表写
int& returnSize,函数中只需returnSize = 10；就可，更直观。案例二：
第二个案例大家如果写过C语言就再熟悉不过了——
scanf()int main() { int a = 0; scanf("%d",&a); }这里a其实就是一个输出型参数，当初刚学这个函数的时候，相信大家一定也漏加过&，
这里如果有了c++的引用语法，只需将
scanf()的参数列表中int* a改为int& a,我们下次直接传a就好。这里还是说引用传参更直观更好理解！！！
做返回值
在解释引用做返回值之前先看看函数普通返回。
int func()
{
int n = 0;
n++;
//...
return n;
}
int main()
{
int ret = func();
return 0;
}
首先问一个问题：这里的 n 能直接传给 ret 吗？
答案是不能，函数调用完func()之后，func()这段栈帧会销毁，也就是说n地址处的值已经不可控了，
所以传返回值的时候，会先传给一个临时变量 ，等回到main()函数之后，再把临时变量传给 ret 变量。
这里的临时变量如果小，就用寄存器充当，如果很大，编译器回在上一层函数栈帧，也就是这里的
main()内部直接开好空间当临时变量，然后再把这个空间里的数据传给ret；有些激进一些的编译器也会直接把ret作为临时变量。
这时再来看一下引用做返回值：
int& func()
{
int n = 0;
cout << "func()_n:" << &n << endl;
return n;
}
int main()
{
int& ret = func();
//这里可以用int接收，临时变量也不用开辟临时空间，加引用只是为了说明这里确实是n的别名
cout << "mian()_ret:" << &ret << endl;
return 0;
}
这里加引用的意义就是把临时变量的类型指定为 int&
也就是说没有额外开空间，这里tmp是n的别名，把 tmp 传给 ret 就相当于把 n传给 ret.
总结：
传值返回：会有一个拷贝
传引用返回：没有这个拷贝，函数返回的直接就是变量的别名
当然这里的示例代码是有问题的，可以说返回了一个已经销毁的变量，发生的非法访问，实际使用肯定不是这样，这个例子仅仅为了是告诉大家，返回引用不会额外开辟空间。
我们运行上面的代码验证一下：
可以证明：这一路下来，一直都没有发生n内容的拷贝。
一般引用做返回值用在什么地方呢？
如果函数返回时，出了函数作用域，如果返回对象还未还给系统，则可以使用引用返回，如果已经还给系统了，则必须使用传值返回，否则会出现越界问题。
引用和指针
不同
-
引用概念上定义一个变量的别名，指针储存一个变量的地址。
-
引用在定义是必须初始化，指针没有要求。
注：虽然指针没有强制初始化要求，但如果没有具体指向，建议初始化为空，因为在用户层面是无法判断指针合法性的，只能是用户在使用阶段就做出标记，便于对非法指针的识别。 -
引用在初始化时引用一个实体后，就
不能再引用其他实体，而指针可以在任何时候指向任意一个同类型实体。 -
没有空引用，但有空指针。
-
在
sizeof中含义不同，引用结果为引用类型的大小，但指针始终是地址空间所占字节的个数（32位平台4字节，64位平台占8字节） -
引用自加即引用实体增加1，指针自加1即指针向后偏移一个类型的大小
-
有多级指针，但有多级引用。
-
访问实体方式方式不同，指针需要显示解引用，引用会编译器自己处理
-
引用比指针用起来更安全
相同——底层原理
int main()
{
int a = 10;
int& ra = a;
ra = 20;
int* pa = &a;
*pa = 30;
}
语法角度而言：
- ra 是 a 的别名，没有额外开辟空间
- pa 储存 a 的地址，pa 开了 4/8byte 的空间
底层角度：
-
它们是一样的实现方式
我们看一下上面那段代码的汇编代码：
不能说很像，只能说一摸一样，看不看得懂不重要，长得像就完了。
这里解释一下：
003F2836 lea eax,[a]
003F2839 mov dword ptr [ra],eax这里的
lea指的是 a 的4取地址放到寄存器中
mov的意思是把寄存器中的值存到ra变量中003F283C mov eax,dword ptr [ra]
003F283F mov dword ptr [eax],14h接下来把ra的值（a的地址）存到寄存器
再拿 20（12h)放到刚刚寄存器存的地址中下面的取地址版本同理
这里的临时变量小会用寄存器充当 ↩︎
636
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
