1.引用
🏞?1.1 引用概念
引用不是新定义一个变量，而是给已存在的变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用一块内存空间.
比如，在家的时候，可能你父母会叫你的小名，但其实无论是小名，还是真名，在称呼的时候，都是在叫你罢了.
理解了引用的概念后，怎么样去使用引用呢？
使用引用的格式是类型& 引用变量名(对象名) = 实体.
注意：引用类型必须和引用的实体是同种类型的
用代码演示:
void TestRef()
{
int a = 10;
int& b = a;
}
这段示例中，我们定义了一个int类型的变量，接着定义了引用变量b引用a，这样，b就成了a的一个别名，那既然b是a的一个别名，并且它们共用一块内存，那么它们的值应该是相同的，并且地址相同，当你去修改b时，a也会被修改.
接下来，我们写代码进行测试:
void TestRef()
{
int a = 10;
int& b = a;
//测试a和b值是否相同
cout << "值：" << endl;
cout << "a：" << a << endl;
cout << "b：" << b << endl;
//测试a和b的地址是否相同
cout << "--------------" << endl;
cout << "地址：" << endl;
cout << &a << endl;
cout << &b << endl;
//测试当修改b时,a是否也会被修改
cout << "--------------" << endl;
cout << "对b进行修改" << endl;
b = 20;
cout <<"a："<< a << endl;
cout <<"b："<< b << endl;
}
在VS中的运行结果：
从运行结果就可以一目了然，b的确是a的一个别名.
?1.2 引用特性
- 1.引用在定义时必须初始化
- 2.一个变量可以有多个引用
- 3.引用一旦引用一个实体，不能再引用其他实体
void TestRef()
{
//1.引用在定义时必须初始化
int &ra; //编译会出错
//2.一个变量可以有多个引用
int &b = a;
int &c = a;
//3.引用一旦引用一个实体，不能再引用其他实体
int d = 10;
int f = 20;
int &rd = d;
rd = f; //这条语句会被当作赋值
}
🌁1.3 常引用
在上面，我们了解了怎样用引用的方式去引用一个变量，那我们能不能引用一个常量呢？
答案是当然可以！
例如我们如何对一个常量10进行引用呢？
如果我们还是用之前的方式对它引用，显然是不行的
int& a = 10; //编译器会报错
对一个常量进行引用,需要在引用的前面加上const来表示常引用
const int& a = 20; //在引用的前面加上const表示常引用
常引用不能通过赋值运算改变它的值.
看这样一段代码：
我们相用一个int类型的引用变量去引用d.
double d = 12.34;
int& rd = d; //错误的
这显然是不行的，在前面我们说过，引用类型必须和引用的实体类型是相同的.
但是，对上面的代码做一点更改：
double d = 12.34;
const int& rd = d;
cout<<rd;
当我们再次到编译器中去运行.
哎，为什么没有报错并且会打印出12呢？
这个12，我们可能会猜到，可能是因为从double到int的转换丢失了精度，从而导致小数部分被截取，但是为什么加上了const这段代码就不会报错了呢？d是一个变量，不是常量呀.
其实，这与赋值的特性有关系：
int b = 10;
int a = b;
这段代码，我们将b赋值给a，它是怎样完成赋值的呢？
其实，首先，会根据变量b拷贝出一个临时变量，再将临时变量赋值给a，而这里的临时变量是具有常属性的.
double d = 12.34;
const int& rd = d;
所以在这里，我们定义引用变量rd去引用d时，其实也是在引用一个根据d拷贝的临时变量，这个临时变量具有常属性，所以我们必须用一个const的引用去引用它才可以.
那当然了，从double到int是会丢失精度的，编译器也是会报警告的.
在引用这里，当我们使用引用引用变量时，并使用const的时候，我们需要记住一个原则：
对原引用变量，权限只能缩小，不能放大
int main()
{
const int x = 20;
int& d = x; //用一个可读可写的引用变量引用const 变量x 变量x的权限被放大 错误
int b = 10;
const int& rb = b; //用一个const引用变量去引用可读可写的b b的权限被缩小 正确
return 0;
}
🌅1.4 应用场景
那么我们学习了引用这个语法，目的就是为了去应用它，所以它都有哪些应用呢？
主要有两个：
- 引用做参数
- 做返回值
1. 引用做参数
void swap(int& a, int& b)
{
int tmp = a;
a = b;
b = tmp;
}
int main()
{
int x = 10;
int y = 20;
swap(x, y);
return 0;
}
在这里，我写了一个简单的交换函数，将函数的参数设置成两个要交换变量的引用，当我们定义了两个变量x和y，想要交换两个变量的值，就可以直接将变量作实参传进去，a和b就会分别引用x和y，此时，操作形参a和b就是操作x和y，a和b的交换就是x和y的交换.
这样的操作方式是不是比我们在C语言当中的用指针作参数简单而且更好理解呢.
2. 引用做返回值
那么引用除了做参数之外，也是可以做返回值的，也就是我们可以通过引用做返回值将变量本身返回到函数调用处.
int& Count()
{
static int n = 0;
n++;
return n;
}
在这里我们定义了一个int类型的变量并用static修饰，那么n变量除了函数作用域不会被销毁，也就可以把n自身返回给调用方去继续使用，我们使用了引用做返回值，将变量本身返回给了调用方.
但是我们不能把一个局部的变量(或对象)返回给调用方，因为它出了函数的作用域就会被销毁，如果再去使用它，那必然就会带来一些问题.那这个时候就必须使用传值返回了.
注意：如果函数返回时，出了函数作用域，如果返回对象还未还给系统，则可以使用引用返回，如果已经还给系统了，则必须使用传值返回.
🌠1.5 传值和传引用效率比较
以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或将变量本身直接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型效率是非常低下的，尤其是当参数或者返回类型特别大时.
所以我们就可以用引用来将函数的实参或者返回值的本身进行传递，这样就不会发生临时的拷贝，从而提升效率.
我们可以写一段代码来测试传引用和传值的效率：
#include<iostream>
#include<time.h>
struct A
{
int a[10000];
};
void Test01(A a)
{
}
void Test02(A& a)
{
}
int main()
{
A a;
size_t begin1 = clock();
for (size_t i = 0; i < 100000; ++i)
{
Test01(a);
}
size_t end1 = clock();
cout << "值传递所用时间：" << endl;
cout << end1 - begin1 << endl;
cout << "---------------" << endl;
size_t begin2 = clock();
for (size_t i = 0; i < 100000; ++i)
{
Test02(a);
}
size_t end2 = clock();
cout << "引用传递所用时间：" << endl;
cout << end2 - begin2 << endl;
return 0;
}
我们使用了两个分别使用值传递和引用传递的函数，分别对它们运行多次，来记录它们所用的时间，对比结果，引用传递的确是比值传递效率更高的.
🌌1.6 引用和指针的区别
我们现在可能会想，引用这么好用，那它是怎么实现的呢？
其实，引用的底层就是通过指针来实现的，只不过引用表面看上去没有指针类似的操作，以一种更为简便的方式呈现在了我们面前.
#include<iostream>
using namespace std;
int main()
{
int a = 10;
int &ra = a;
int b = 10;
int *pb = &b;
return 0;
}
当我们将上述代码放到编译器转到反汇编去查看时，会发现，用指针和用引用时，它们的汇编代码执行的操作是一模一样的，那也就是说，其实 引用就是用指针来实现的.
在语法概念上，引用就是一个别名，没有独立空间，和其引用实体共用一块空间.
在底层实现上其实是有空间的，因为引用是按照指针的方式实现的
可能有人不知道怎样在VS下查看反汇编代码，在这里我做一下演示：
一.用fn+F9在语句前打上断点
二. 按fn+F5开始调试，程序将会跳转运行到该语句处：
三.接着在语句处点击右键，选择转到反汇编
通过这三步即可顺利查看反汇编代码.
最后，总结一下引用和指针的不同点：
- 引用在定义时必须初始化，指针没有要求
- 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型的实体
- 没有NULL引用，但用空指针
- 在
sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数（32平台下为4字节） - 引用自加即引用的实体加1，指针自加即指针向后偏移一个类型的大小
- 有多级指针，但没有多级引用
- 访问实体方式不同，指针需要显示解引用，引用编译器自己处理
- 引用比指针使用起来相对更安全
2. 内联函数
?2.1 概念
以inline修饰的函数叫做内联函数，编译时C++会在调用内联函数的地方将内联函数展开，没有函数压栈的开销，内联函数提升程序运行的效率.
通过写代码来直观的看：
#include<iostream>
using namespace std;
int Add(int x, int y)
{
return x + y;
}
int main()
{
int ret = 0;
ret = Add(1, 2);
return 0;
}
通过反汇编可以看到，编译器通过汇编指令call调用了Add函数，对传进去的值进行加法操作并返回.
但是当我们在函数前面加上inline关键字将其改成内联函数，在编译期间编译器会用函数体替换函数的调用.
我们可以有两种查看方式去查看它的替换：
1.在release模式下，查看编译器生成的汇编代码中是否存在call Add
2.在debug模式下，需要对编译器进行设置，否则不会展开
在debug下，VS2019中需要
1.首先将常规中的调试信息格式改成如图
!
2.然后将优化中的内联函数扩展改成只适用于_inline
#include<iostream>
using namespace std;
inline int Add(int x, int y)
{
return x + y;
}
int main()
{
int ret = 0;
ret = Add(1, 2);
return 0;
}
将上述代码通过反汇编查看，可以看出，此时编译器不再调用Add函数，而是直接替换，执行了加法操作.这是inline内联函数优化的结果
🌇2.2 特性
1.inline是一种以空间换时间的做法，省去调用函数开销. 因此代码很长或者有循环/递归的函数不适宜做内联函数.
2.inline内联函数对编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环/递归等等，编译器优化时会忽略掉内联.
3.inline不建议声明和定义分离，分离会导致链接错误，因为inline内联函数被展开，就不会生成符号表了，链接时就会找不到对应的函数.
假如我们写出如下代码，Add函数内实现较长，此时当我们再去查看反汇编时：
#include<iostream>
using namespace std;
inline int Add(int x, int y)
{
int a = x + y;
a = x + y;
a = x + y;
a = x + y;
a = x + y;
a = x + y;
a = x + y;
a = x + y;
a = x + y;
a = x + y;
a = x + y;
a = x + y;
return a;
}
int main()
{
int ret = 0;
ret = Add(1, 2);
ret = Add(2, 3);
ret = Add(2, 3);
ret = Add(2, 3);
ret = Add(2, 3);
ret = Add(2, 3);
ret = Add(2, 3);
ret = Add(2, 3);
ret = Add(2, 3);
ret = Add(2, 3);
ret = Add(2, 3);
return 0;
}
这里会发现，编译器并没有选择将Add函数在调用处展开，因为Add函数较长，如果都展开会使代码量增加很多，已经得不偿失了.所以inline内联函数对于编译器只是建议，具体是否展开还是由编译器决定.
接下来，我们还可以尝试一下将inline函数的定义和声明分离：
我们分别定义了F.h F.cpp Test.cpp三个源文件来测试：
最终，我们运行Test.cpp会发现，编译器会报错：无法解析的外部符号，发生了链接错误.
所以，不要把inline内联函数的声明和定义分离开来.
