C++入门知识（三）：引用、内联函数与 nullptr 概念

在这段代码中，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 的出现就是为了让指针在定义的时候意义统一。