1、引用 -- &
1.1 引用的概念
引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。
比如：李逵，在家称为“铁牛”，江湖上人称“黑旋风”。同一个人，只不过是两个名字。
语法： 类型& 引用变量名（对象名） = 引用实体；
&是引用的符号，在C语言中&也表示取地址，还表示按位与，本质是运算符重载，运算符重载，一个符号会根据不同的场景，编译器会自己确定含义。
我们举例来看看&：
int main() { int a = 10; int& b = a;//定义引用类型 int& c = b; cout << "a = " << a << "，地址：" << &a << endl; cout << "b = " << b << "，地址：" << &b << endl; cout << "c = " << c << "，地址：" << &c << endl; return 0; }
运行结果：
我们根据运行结果可以知道，a,b,c 指的是同一块内存空间。
注意：引用类型必须和引用实体是同种类型的。
1.2 引用特性
引用有三个特性：
1. 引用在定义时必须初始化；
2. 一个变量可以有多个引用；
3. 引用一旦引用一个实体，再不能引用其他实体。
其实前两条我们理解记忆就好了：
1、引用是起别名，要有对象我们才能再去起别名，不存在对象给谁起别名；
2、一个小孩，妈妈可以叫他宝贝，爸爸可以叫他贝贝，爷爷也可以叫他狗蛋是吧，所以一个对象可以有多个别名（引用）。
我们对这三个用代码写一下看看：
1.3 常引用 -- 权限问题
我们用代码来看：
int main() { //1.权限放大 const int x = 10; int& a = x; return 0; }
我们来看看编译会不会出错：
这是因为，在引用中，对原变量的引用权限不能放大。
在这段代码中，x是const修饰的常变量，只能读取，不能修改。而a是int类型，针对类型来说，它是可以修改的。因此这就是权限放大，这是错误的。
我们继续往下看：
int main() { //2.权限平移 const int i = 20; const int& j = i; //3.权限缩小 int z = 30; const int& y = z; return 0; }
我们看结果：
对于权限的平移，权限的缩小都是没有问题的，由此我们可以看出：在引用中，对于权限来说，平移、缩小都是没有问题的，唯独要注意的是：权限不能放大。
特殊：
我们再往下看：
直接能看出来，对于引用来说不能初始化为常量，这也算是权限的放大。 
改为const修饰就不会报错了。
最后看一个： 
引用的时候，不同的类型直接引用是会出错的，本质原因是int类型赋给double类型存在隐式类型转换，生成一个临时变量（具有常性），因此需要加const修饰。
1.4 引用的使用场景
1.4.1 做参数
void Swap(int& left, int& right) { int tmp = left; left = right; right = tmp; }
在C语言的时候，我们交换两个数我们使用指针来交换，而C++我们就可以使用引用来交换。
我们来测试一下：
1.4.2 做返回值
我们先来看一段代码：
int func() { int n = 0; n++; return n; } int main() { cout << func() << endl; return 0; }
运行结果：
这是是一个传值返回，我们来深究传值返回的过程：
传值返回的时候会产生一个临时变量，跟传参一样，临时变量会先把n拷贝下来，然后再拷贝给函数调用，传值返回的类型其实是临时变量的类型，那么为什么要产生一个临时变量呢，直接返回n不香吗？
这是因为在函数调用的时候，功能函数会建立函数栈帧，而功能函数的每一条语句执行完后，函数栈帧会自动销毁，这时功能函数的整个函数体，包括函数体里的所有内容都随之销毁，返回的变量生命周期也就结束了。但是编译器在这里产生一个临时变量，要是小就用寄存器存储，将返回值拷贝给临时变量，再又临时变量拷贝给调用的函数，这就不会出错了。
有了上面的理解，我们再来看一段代码：
int& func() { int n = 0; n++; return n; } int main() { int& ret = func(); cout << ret << endl; cout << ret << endl; return 0; }
运行结果：
此代码的返回值是int&，而传引用是给变量起别名，而在这里返回的是别名，调用完func函数，栈帧销毁了，但是空间还在（类似于订酒店，我退房了，但是房间还在，别人还可以使用），给n起了别名之后再去打印，还是操作的n的那块空间，那块空间可能被清理的，也有可能还没有清理，如果没清理，那块空间的值还是1，如果被清理了可能就是其他值了。
注意
我们看上面的代码，在第二次打印的时候，n的值明显就不正确了，出了函数作用域，func函数被销毁了，我们再去访问那块空间的时候，就是非法访问了，这就是引用的一种野指针。
因此这里要注意：如果函数返回时，出了函数作用域，如果返回对象还在(还没还给系统)，则可以使用引用返回，如果已经还给系统了，则必须使用传值返回。
1.5 传值、传引用的效率比较
我们用代码来测试一下：
#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 time:" << end1 - begin1 << endl; cout << "TestFunc2 time:" << end2 - begin2 << endl; } int main() { TestRefAndValue(); return 0; }
运行结果：
#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; }
运行结果：
我们看到无论是传参还是返回，传引用的效率明显要高于传值。
原因： 以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低。
1.6 引用和指针的区别
在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。
int main() { int a = 10; int& ra = a; ra = 20; int* pa = &a; *pa = 20; return 0; }
我们来看引用和反汇编代码的对比：
引用和指针的不同点:
1. 引用概念上定义一个变量的别名，指针存储一个变量地址。
2. 引用在定义时必须初始化，指针没有要求
3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体
4. 没有NULL引用，但有NULL指针
5. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)
6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
7. 有多级指针，但是没有多级引用
8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理
9. 引用比指针使用起来相对更安全
