一、引用
1、引用的概念和使用方法
引用就是 给 变量取个别名(“外号”)
引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。
比如：李逵，在家称为"铁牛"，江湖上人称"黑旋风"。
使用公式+举个例子:
公式：
类型& 引用变量名(对象名) = 引用实体；
注意：引用类型必须和引用实体是同种类型的
注意，因为 引用 和 本体指向的都是同一块空间，因此 C++ 的引用，在某些程度上可以替代掉 C语言中 麻烦的 指针
如图：对应的都是同一块空间地址
演示：可以发现 引用& ，可以直接修改数值，相当于 C语言中的一级指针了
因为C语言，想要修改一个变量的值，需要传递 一级指针，通过指针找到变量的对应地址，才能修改
而 C++ 的引用直接就可以 修改：因为 引用 和 本体指向的都是同一块空间
2、引用的特性
（1）引用在定义时必须初始化：取一个外号必须指定一个人，不能空着：int& a;
（2）一个变量可以有多个引用：一个人取多个外号
（3）引用一旦引用一个实体，再不能引用其他实体：一个外号只能表示一个人
举例：是直接赋值
3、（面试题：考C++的引用/C语言的const的不同位置）常引用（权限可以缩小平移，不能放大）
（1）权限放大：不可以
int main()
{
// x 的权限：只读
// y 的权限：可读可写
// 造成权限放大
const int x = 10;
int& y = x; // 错误写法
const int& y = x; // 正确写法
return 0;
}
（2）权限的平移 和 权限的缩小：都可以
int main()
{
// 权限的平移
int x = 10;
int& y = x;
// 权限的缩小：缩小 x 的权限
const int& z = x;
return 0;
}
思考：结合上面的样例，y 的修改会不会影响 z （x 权限的缩小后的别名）？
先表明：别名的修改可以影响到本体，（你的真实名字和两个外号 不都是代表你自己吗）
答：会影响到，本质是：z 的权限缩小了，只是不能通过 z 来修改 x，但可以通过其他的别名修改 y（就是 z 的功能被限制了而已）
（3）拓展与回顾：C语言中关键字 const 的不同位置
C语言中关键字 const 处于不同位置影响：下面代码，不可修改的地方呢都会报错
int main()
{
int a = 10;
int b = 20;
int c = 30;
int d = 40;
// 1、只要 const 位于 *号的左边，const 就修饰 *pa 和 *pb
const int* pa = &a;
int const* pb = &b;
// 被 const 修饰过就不能修改：下面两个都报错
*pa = 100;
*pb = 200;
// 2、只要 const 位于 *号的右边，const 就修饰 pa 和 pb
int* const pc = &c;
pc = &b; // 被 const 修饰过就不能修改，则这里报错
// 3、const 在 *号的左右都有，则 *pd 和 pd 都不能修改
const int* const pd = &d;
pd = &a;
*pd = 100;
return 0;
}
都是因const修饰导致不可修改 而报错
4、引用和指针的不同点:
-
引用概念上定义一个变量的别名，指针存储一个变量地址。
-
引用在定义时必须初始化，指针没有硬性要求
-
引用在初始化时引用一个实体后，就不能再引用其他实体（比如吴彦祖是你的外号（doge），则这个外号就不能代表别人，也不能更换成别人了），而指针可以在任何时候指向任何一个同类型实体（引用不能再修改，指针可以）
-
没有NULL引用，但有NULL指针
-
在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节，64位平台下占8个字节)
如何理解引用结果为引用类型的大小？
因为引用实际上也算作某片类型空间的主人，如 int a，变量 a 空间大小为 4，而 int& b = a，则别名空间大小肯定也为 4
类型是多大，引用就是多大
-
引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
-
有多级指针，但是没有多级引用
-
访问实体方式不同，指针需要显式解引用（要自己解引用处理），引用编译器自己处理
-
引用比指针使用起来相对更安全
5、思考题：引用 和 指针 语法上不同，底层 相同？
注意：引用和指针的底层都是一样的，都需要开一个空间存储地址
引用 在 语法上不用开空间
指针 在 语法上需要开空间
因而不同
但是在 汇编底层，可以发现都是一样的步骤
6、思考题：关于 引用 的 强制类型转换（涉及权限放大 与 常性临时变量的生成）
看上面代码的报错，产生一个问题：将 a 赋值给 b 和 c ，明明都是强制类型转换，为什么只有 b 报错，而 c 正确？
解析：首先要明白，强制类型转换时，不是直接转换过去的，而是先生成一个临时变量存储 变量 a，再取 int 的部分赋值给 b 和 c
但要注意，这个临时变量具有常性（被const 修饰），因此直接将 a 强转给 b，引用的是临时变量，属于权限放大，所以引用也要加上 const 修饰
拓展：使用 引用 都需要注意，这类产生常性临时变量的运算：
（计算机的一般的表达式运算都会产生临时变量，本质上所有运算对于计算机来说都是加法运算，因为在计算机运算过程中，可能需要拷贝原来的值放到寄存器等等其他地方，用于运算，这些过程就是会产生临时变量）
7、思考题：给空指针取别名（引用）会不会出错？
// 代码如下
int main()
{
int* a = NULL;
int& b = *a; // 引用这一层在底层只是用一个指针把 a 的地址存起来，并没有解引用
cout << b << '\n'; // 这一层才会真正访问，才会解引用，才会出现对NULL的错误访问的情况
return 0;
}
8、传值、传引用、传指针 的效率对比（体会 [引用] 的强大的高效率吧）
（1）先看对比（代码与结果）
我们这里使用 一个 有着 4万个字节的数组，同时使用 十万次传参，来比较 三种传参方式的效率差异
#include <time.h>
struct A { int a[10000]; };
void TestFunc1(A a) {}
void TestFunc2(A& a) {}
void TestFunc3(A* pa) {}
void TestRefAndvalue()
{
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();
// 以一级指针作为函数参数
size_t begin3 = clock();
for (size_t i = 0; i < 100000; ++i) {
TestFunc3(&a);
}
size_t end3 = clock();
// 分别计算两个函数运行结束后的时间
cout << "TestFunc1(A)-time:" << end1 - begin1 << " ms" << endl;
cout << "TestFunc2(A)-time:" << end2 - begin2 << " ms" << endl;
cout << "TestFunc3(A)-time:" << end3 - begin3 << " ms" << endl;
}
int main()
{
TestRefAndvalue();
return 0;
}
运行结果
函数一：传值
函数二：传引用
函数三：传一级指针
（2）解析：
以值作为参数，在传参期间，函数不会直接传递实参，而是传递实参的一份临时的拷贝，因此用值作为参数，效率是非常低下的，尤其是当参数非常大时，效率就更低。（你传值到函数，还要拷贝一次，效率肯定相对较低的啦）
而 引用 本质和实体指的是 同一块空间，某种意义来说，传参用引用接收，相当于 直接传那个实参过去，不用拷贝
传递 一级指针，原理是传递 实参的地址过去
根据对比：使用 引用 和 一级指针，本质上就肯定比 你传过去还要拷贝一次的 传值 高效得多
9、思考题：C++的引用看起来这么强，那可不可以完全替代掉指针了？
不可以，每一种设计，都有其存在的意义，存在即合理，C++之父在设计C++时，就是为了优化C语言，并不是完全替代掉C语言
比如：链表的设计，需要用到 指针可以改变指向的 功能，而引用就不行
（拓展：Java就没有指针，但是Java的引用可以指向下一个地址）