一、引用
1.1、引用的概念和定义
引用不是定义一个新变量，而是给已经存在的变量起一个别名。编译器不会为别名重新开辟空间，它和引用变量共同使用同一块内存。就好比我们把土豆称为马铃薯，番茄称为西红柿一样，都是取了一个新的别名，但是东西是同一个东西。
语法如下：
类型& 别名 = 变量
使用方法如下：
int a = 10;
int& num = a;
num 就是 a 的新名字，同时 num 的值也和 a 一样，是 10。
在 C++ 引用中，&的含义是给变量起别名，而不是 C 语言中的取地址。
1.2、引用的三个特性
1.2.1、引用在定义时必须初始化
在使用引用的时候，一定要先有被引用对象，不能在没有被引用对象的情况下使用引用：
#include<iostream>
using namespace std;
int main() {
int a = 10;
int& num = a;//这是正确的，因为已经有了被引用对象 a
// int& num;//这是错的！因为没有使用被引用对象！！！
return 0;
}
不初始化就相当于'有人有一个外号叫小明'，但是我们不知道是谁的外号叫小明；如果初始化了，那就相当于'张三的外号叫小明'，这样一来，我们就知道小明是张三的外号。
1.2.2、一个变量可以有多个引用
一个变量，可以有一个两个三个别名：
#include<iostream>
using namespace std;
int main() {
int a = 10;
int& num1 = a;
int& word = a;
int& word2 = word;
cout << &a << endl;
cout << &num1 << endl;
cout << &word << endl;
cout << &word2 << endl;
return 0;
}
在这段代码中，num1, word, word2 都是变量 a 的别名。从运行结果可以看出，它们的地址都一样，说明一个变量确实是可以有多个别名的。
1.2.3、引用只能引用一个实体
当一个变量被引用而产生了一个新的别名，那么这个别名就只能用在这个变量身上，不能再去引用其他变量：
#include<iostream>
using namespace std;
int main() {
int b = 10;
int a = 20;
int& num1 = b;
// int& num1 = a;//在这里就会报错
return 0;
}
这就是告诉我们，num1 引用了不止一个变量。用人话来说就是：张三有个外号叫小明，但是李四的外号也叫小明，这就会让朋友们造成困惑，小明到底指的是谁？这就是错误的，所以一个外号只能对应一个人。但一个人可以有多个外号。
小总结：引用必须在定义时就绑定到某个变量，不能'先定义后绑定'。一个变量可以有多个引用（多个别名），但一个引用只能绑定到一个变量，且绑定后不能再指向其他变量。
1.3、引用的使用
引用的作用主要是用在函数传参和传返回值。C 语言的函数传参方式是通过拷贝实参传入形参，当数据量非常大的时候，会让函数栈帧的压力非常大，导致效率降低。尤其是在传入指针的时候，极易出现空指针、野指针的相关问题，安全性差。为了解决这个问题，C++ 引入了引用来解决这类问题。
场景 1：函数传参优化
为了更好的了解引用在实际编程中的作用，我们从一个简单的函数入手：
#include<iostream>
using namespace std;
void Swap(int* x, int* y) {
int temp = *x;
*x = *y;
*y = temp;
}
int main() {
int a = 10;
int b = 20;
cout << a << " " << b << endl;
Swap(&a, &b);
cout << a << " " << b << endl;
}
这是一个非常简单的交换函数，程序在运行的时候要先拷贝一份实参再传入形参，然后再通过指针对形参进行解引用，才能完成交换这个动作，这样一来会降低编写的速度和程序运行的效率。但如果使用引用呢？
#include<iostream>
using namespace std;
void Swap(int& x, int& y) {
int temp = x;
x = y;
y = temp;
}
int main() {
int a = 10;
int b = 20;
cout << a << " " << b << endl;
Swap(a, b);
cout << a << " " << b << endl;
return 0;
}
如果使用引用，那么在传参时就可以理解为：int& x, int& y 分别是 main 函数中 a, b 的别名，就相当于直接对 a 和 b 进行交换，传了别名进去就相当于传了我进去。在语法上就更加好理解，编写代码起来也就更加顺畅。
场景 2：链表操作优化
思绪回到我们学习数据结构的时候：在单链表中，如果没有头节点，就需要不断地使用二级指针将头节点的地址传进去：
#include<stdio.h>
#include<stdlib.h>
typedef struct ListNode {
struct ListNode* next;
int val;
}ListNode;
void Push_elem_front(ListNode** ppheadNode, int elem) {
//...
}
void Printf_elem(ListNode* pheadNode) {
//...
}
int main(){
ListNode* phead = nullptr;
//...
return 0;
}
因为本质上是对头节点进行改变，但是有没有哨兵位，想要对链表进行操作只能是对头节点进行操作，也就是修改头节点指向的地址。想要修改头节点指向的地址，只能通过头节点地址的地址，也就是二级指针进行操作，这样一来会让人理解混乱，不容易编写代码。但是如果我们使用引用呢？
#include<iostream>
using namespace std;
typedef struct ListNode {
struct ListNode* next;
int val;
}ListNode;
void Push_elem_front(ListNode*& head_of_List, int elem) {
//...
}
void Printf(ListNode* phead, int elem) {
//...
}
int main() {
ListNode* phead = nullptr;
//...
return 0;
}
在这段实例里面，尤其是在 Push_elem_front() 函数中，就是给 phead 起了个别名，叫做 head_of_list，这样一来，就相当于直接将 phead 的地址直接传入函数中，就不用二级指针进行接收了，更加方便理解。
课本中有时只用了一个引用而已，原因就在这里：
typedef struct ListNode{
struct ListNode* next;
int val;
}ListNode,*pListNode;
这段代码本来应该是这样的：
typedef struct ListNode ListNode;
typedef struct ListNode* pListNode;
将链表节点的地址重命名为 pListNode，这样一来，在函数参数中就可以直接对 pListNode 继续引用：pListNode& phead，等价于 ListNode* phead。
上面的两个场景就是引用在函数传参的经典使用场景。
那么下面我们来讲讲引用在返回值上的使用：
场景 3：返回引用
依旧是链表为例。我们在链表中总是要用到查找吧？就是通过指针遍历一次链表，看看哪个节点的值是符合要求的，就返回这个节点的值。我们之前是这么写的：
#include<iostream>
#include<stdlib.h>
using namespace std;
typedef struct ListNode {
struct ListNode* next;
int val;
}ListNode;
int getNodeVal(ListNode* phead, int pos) {
ListNode* pcur = phead;
int count = 1;
while (count != pos && pcur!=NULL) {
pcur = pcur->next;
count++;
}
//...
return pcur->val;
}
int main() {
ListNode* phead = nullptr;
int pos = 2;
int num_of_pos = getNodeVal(phead, pos);
cout << num_of_pos << endl;
return 0;
}
函数中返回的是 pos 节点的值，但是想要修改这个节点的值，我就需要将该节点的值的地址返回，通过解引用值的地址才能实现值的修改。但如果是引用的话，查找和修改简直是一举两得：
int& getNodeVal(ListNode* phead, int pos) {
ListNode* pcur = phead;
int count = 1;
while (count != pos && pcur!=NULL) {
pcur = pcur->next;
count++;
}
//...
return pcur->val;
}
int main() {
ListNode* phead = nullptr;
int pos = 2;
int num_of_pos = getNodeVal(phead, pos);
cout << "修改之前：" << num_of_pos << endl;
getNodeVal(phead, pos) = 200;
num_of_pos = getNodeVal(phead, pos);
cout << "修改之后：" << num_of_pos << endl;
return 0;
}
那么在这段代码中，返回的就是节点的值的别名，可以直接通过别名对节点的值直接进行修改。但是有同学又要问了，为什么是 getNodeVal(phead,pos) = 200 就能实现值的修改呢？因为，这段代码的本质是这样的：
int& getNodeVal(phead,pos) = pcur->val;
getNodeVal(phead,pos) = 200;
如果是这样我就理解了，但为什么函数结束之后还能通过引用找到这个节点的值呢？因为啊，节点是结构体，结构体是存在内存中的堆区，这样的话就算函数结束了这个节点的地址依旧可以被找到。
那么上面三个场景就是引用在代码中实际应用中的表现了，这就解决了指针在这方面不够灵活的缺点。但是，下面就有两个问题了：
问题 1：引用可以代替指针吗？
答案是不能。因为引用虽然能带来指针带不来的快捷，但是在需要用到修改指向问题的时候，只有指针能用，引用无法修改指向！！！像链表的插入呀，树，节点位置定义等等场景都是要用到指针的。
问题 2：可以返回临时变量的引用吗？
答案是不能，像下面的例子：
#include<istream>
using namespace std;
int& Func() {
int temp = 10;
return temp;
}
int main() {
int ret = Func();
return 0;
}
这段代码运行起来会有这样一个报错。也就是说，我们返回了一个临时变量的别名，这时不被允许的。为什么？因为当主函数要调用 Func() 函数的时候，系统会为 Func() 函数开辟空间，同时也为 temp 变量开辟空间。当函数执行完后，系统会回收函数的这部分空间，从物理上来说，temp 变量在使用的时候是有位置的，但是系统回收空间后，原本是 temp 变量的位置现在 temp 已经不在了，但是那块地还在，算是人去楼空的状态了。这时候主函数在通过别名返回去找 temp，就不一定找的到了，所以会报这么一个错误。
1.4、const 引用
作用 1：防止变量被修改
当我们在编写大程序的时候，希望我们的变量不要被修改，就可以用 const 引用：
int a = 10;
const int& num = a; //num = 100 ,这时错误的，别名不能被修改
这时就有同学要问了，const int& 和 const int 有什么区别？请看下面代码就明白了：
#include<iostream>
using namespace std;
int main() {
int a = 10;
//const int: const int val = a;
//a = 20;
//cout << "after a change:" << val << endl;//此时 val 是不会受到 a 的影响，只会一直保持最开始的值
const int& num = a;
a = 20;
cout << "after a change:" << num << endl;//此时 num 会跟着 a 的改变而改变，因为 num 是 a 的别名，与 a 融为一体了
//val = 10
//num = 10 这些都是错误的，因为被 const 修饰的值不能被修改!!!
return 0;
}
还有就是如果原本的变量是 const int 呢？那引用就只能用 const int&。
#include<iostream>
using namespace std;
int main(){
int a = 10;
const int& val = a;//这是对的
int& val2 = a;//这也是对的
const int b = 10;
const int& val1 = b;//这也是对的
//int& val3 = b; 这是错的！！！人家原本的变量都不能被修改，你这个别名怎么敢称为可修改值的？
return 0;
}
作用 2：效率优化
同样是在编写大程序的时候，如果函数中要传参的对象非常大，像结构体，数组这种，传统的拷贝传值是非常消耗内存的，严重的甚至会导致程序崩溃，但如果这时候用上 const 引用，问题就迎刃而解了：
//C 语言：传大的结构体，要拷贝 100 份（假设），开销极大
typedef struct {
int arr[1000];
} BigStruct;
void read(BigStruct s) {}
//C++：只用传别名即可
void read(const BigStruct& s) {}
作用 3：隐式类型转换（灵活兼容特性）
我们经常会将浮点数转换为整数，一般情况下我们是这么写的：
#include<iostream>
using namespace std;
int main(){
double a = 3.14;
//中间其实还有 int temp = (int)a 这一步的
const int& b = a;
cout<<a<<endl;//输出 3.14 不变
cout<<b<<endl;//输出 3
return 0;
}
那么以上就是 const 引用的内容了。
1.5、引用和指针的关系
C++ 中指针和引用就像两个性格迥异的亲兄弟，指针是哥哥，引用是弟弟，在实践中他们相辅相成，功能有重叠性，但是各有自己的特点，互相不可替代。
- 语法概念上引用是一个变量的取别名不开空间，指针是存储一个变量地址，要开空间。
- 引用在定义时必须初始化，指针建议初始化，但是语法上不是必须的。
- 引用在初始化时引用一个对象后，就不能再引用其他对象；而指针可以在不断地改变指向对象。
- 引用可以直接访问指向对象，指针需要解引用才是访问指向对象。
- sizeof 中含义不同，引用结果为引用类型的大小，但指针始终是地址空间所占字节个数 (32 位平台下占 4 个字节，64 位下是 8byte)。
- 指针很容易出现空指针和野指针的问题，引用很少出现，引用使用起来相对更安全一些。
二、inline 内联函数
被 inline 修饰的函数叫做内联函数，编译时 C++ 编译器会在调用的地方直接展开内联函数，并不会额外给函数建立栈帧，由此就提高了程序的编译效率。像这样：
#include<iostream>
using namespace std;
inline int add(int a, int b) {
return a + b;
}
int main() {
int a = 1, b = 2;
cout << add(a,b) << endl;
return 0;
}
在调用反汇编的时候就能看到，系统是直接将 add 的结果放到寄存器上面的，减少了 add 函数额外创建栈帧的开销。但如果没有 inline 修饰函数，将会是这样的，会使用 call 指令跳转到 add 函数的位置，然后为 add 函数重新建立栈帧，这就会降低程序运行的效率。
但是呢，inline 内联函数对于编译器只是一个建议的作用，就是建议编译器将这个函数看成内联函数，但是要不要将其看成内联函数，就取决于编译器了。如果这段代码使用递归等会消耗性能的时候，编译器也会将其看成普通的函数进行处理。
那么 inline 内联函数解决的是 C 语言的哪些问题呢？是宏。
C 语言实现宏函数也会在预处理时将其展开，但是一旦函数复杂，那就很容易出错，且宏不容易调试，所以 inline 就是为了解决 C 语言宏的问题。
在一些代码量少但是被频繁使用的函数中，使用 inline 就能大幅减少时间。假设我现在有 10000 行带代码和一个 20 行的函数，要调用 100 次这段代码，使用内联函数就只用 10020 行，如果不使用 inline 函数，那就要用 10000+20*100 = 12000 行代码编译，性能差距还是非常大的。
小贴士：inline 不建议声明和定义分离到两个文件，分离会导致链接错误。因为 inline 被展开，就没有函数地址，链接时会出现报错。
三、nullptr
我们之前看见的 NULL 其实是一个宏，在 C 语言和 C++ 环境下是由不同含义的：
#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif
由于 NULL 在不同环境下被定义成不同的意思，所以为了方便编写，C++ 标准引入了 nullptr 这一个关键字，用来将所有指针类型初始化成空指针，这样就不会因为意思的不同而导致程序出错：
#include<iostream>
using namespace std;
void f(int x) {
cout << "f(int x)" << endl;
}
void f(int* x) {
cout << "f(int* x)" << endl;
}
int main() {
f(0);
f(nullptr);
f(NULL);
return 0;
}
我们平时在初始化指针的时候都是喜欢用 NULL，因此在上面这个程序中我们也希望 NULL 调用的是 int* 类型的，但是运行结果如下，可见 NULL 在 C++ 环境下调用的是 int x 类型的，这样就不能用于指针的初始化了，所以用 nullptr 是最好的方法。
nullptr 的出现就是为了让指针在定义的时候意义统一。
