【C++初阶(三）引用与内联函数】

本专栏内容为：C++学习专栏，分为初阶和进阶两部分。 通过本专栏的深入学习，你可以了解并掌握C++。

💓博主csdn个人主页：小小unicorn
⏩专栏分类：C++
🚚代码仓库：小小unicorn的代码仓库🚚
🌹🌹🌹关注我带你学习编程知识

引用

概念

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。

比如：李逵，在家称为"铁牛"，江湖上人称"黑旋风"。

其使用的基本形式为：类型& 引用变量名(对象名) = 引用实体。

#include 
using namespace std;
int main()
{
	int a = 10;
	int& b = a;//给变量a去了一个别名，叫b
	cout << "a = " << a << endl;//a打印结果为10
	cout << "b = " << b << endl;//b打印结果也是10
	b = 20;//改变b也就是改变了a
	cout << "a = " << a << endl;//a打印结果为20
	cout << "b = " << b << endl;//b打印结果也是为20
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

注：引用类型必须和引用实体是同种类型.

引用的特性

一、引用在定义时必须初始化

//正确示例：
int a = 10;
int& b = a;//引用在定义时必须初始化

//错误示例：
int c = 10;
int& d;//定义时未初始化
d = c;

1
2
3
4
5
6
7
8
9
10

二、一个变量可以有多个引用（多个别名）

例如：

int a = 10;
int& b = a;
int& c = a;
int& d = a;

1
2
3
4
5

三、引用一旦引用了一个实体，就不能再引用其他实体

例如：

	int a = 10;
	int& b = a;
1
2

此时，b已经是a的引用了，b不能再引用其他实体。如果你写下以下代码，想让b转而引用另一个变量c：

	int c = 20;
	b = c;//你的想法：让b转而引用c
1
2

但该代码并没有随你的意，该代码的意思是：将b引用的实体赋值为c，也就是将变量a的内容改成了20。

常引用

上面提到，引用类型必须和引用实体是同种类型的。但是仅仅是同种类型，还不能保证能够引用成功，我们若用一个普通引用类型去引用其对应的类型，但该类型被const所修饰，那么引用将不会成功。

int main()
{
     // 权限不能放大
	const int a = 10;
	//int& ra = a;    //该语句编译时会出错，a为常量
	const int& ra = a;//正确
	
	// 权限可以缩小
	//int& b = 10;    //该语句编译时会出错，10为常量
	const int& b = 10;//正确
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

我们可以将被const修饰了的类型理解为安全的类型，因为其不能被修改。我们若将一个安全的类型交给一个不安全的类型（可被修改），那么将不会成功。

引用的使用场景

引用做参数

还记得C语言中的交换函数，学习C语言的时候经常用交换函数来说明传值和传址的区别。现在我们学习了引用，可以不用指针作为形参了：

/交换函数
void Swap(int& a, int& b)
{
	int tmp = a;
	a = b;
	b = tmp;
}
1
2
3
4
5
6
7

因为在这里a和b是传入实参的引用(也就是说起别名），我们将a和b的值交换，就相当于将传入的两个实参交换了。

引用做返回值

当然引用也能做返回值，但是要特别注意，我们返回的数据不能是函数内部创建的普通局部变量，因为在函数内部定义的普通的局部变量会随着函数调用的结束而被销毁。我们返回的数据必须是被static修饰或者是动态开辟的或者是全局变量等不会随着函数调用的结束而被销毁的数据。

先看下面这个例子：

int& Add(int a, int b)
{
	int c = a + b;
	return c;
}
1
2
3
4
5

我们会发现：这里的结果是一个随机值，这是因为：如果函数返回时，出了函数作用域，返回对象还未还给系统，则可以使用引用返回；如果已经还给系统了，则必须使用传值返回。

int& Add(int a, int b)
{
	static int c = a + b;
	return c;
}
1
2
3
4
5

引用与指针的区别

在语法概念上，引用就是一个别名，没有独立的空间，其和引用实体共用同一块空间。

int main()
{
	int a = 10;
	//在语法上，这里给a这块空间取了一个别名，没有新开空间
	int& ra = a;
	ra = 20;

	//在语法上，这里定义了一个pa指针，开辟了4个字节（32位平台）的空间，用于存储a的地址
	int* pa = &a;
	*pa = 20;
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13

我们转到反汇编下，其实在底层实现上，引用实际是有空间的：

从汇编角度来看，引用的底层实现也是类似指针存地址的方式来处理的。

引用和指针的不同点:（重要！！！）

1. 引用概念上定义一个变量的别名，指针存储一个变量地址。
2. 引用在定义时必须初始化，指针没有要求
3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体
4. 没有NULL引用，但有NULL指针
5. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)
6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
7. 有多级指针，但是没有多级引用
8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理
9. 引用比指针使用起来相对更安全

内联函数

在引出内联函数前，我们先用之前C语言学过的宏，用宏来定义一个Add函数。

#define Add(x,y) ((x)+(y))
1

测试一下：

int main()
{
	int ret1 = ADD(2, 3) * 5; // （(2)+(3))*5
	cout << "ret1=" << ret1 << endl;
	return 0;
}
1
2
3
4
5
6

这里我们用宏直接定义Add函数，看似代码先比较写一个Add函数来说间接了不少，但是用宏也会有缺点：
1、容易出错，语法细节多
2、不能调试
3、没有类型安全的检查

所以我们就用 enum const inline 来替代宏

其中：
enum const -> 宏常量
inline ->宏函数

而用inline用来修饰的函数就叫做内联函数。

内联函数的概念

以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数压栈的开销，内联函数的使用可以提升程序的运行效率。
 我们可以通过观察调用普通函数和内联函数的汇编代码来进一步查看其优势：
 
不用inline修饰：

int Add(int a, int b)
{
	return a + b;
}
int main()
{
	int ret = Add(1, 2);
	return 0;
}
1
2
3
4
5
6
7
8
9

用inline修饰后：

int Add(int a, int b)
{
	return a + b;
}
int main()
{
	int ret = Add(1, 2);
	return 0;
}
1
2
3
4
5
6
7
8
9

下图左是以上代码的汇编代码，下图右是函数Add加上inline后的汇编代码：

从汇编代码中可以看出，内联函数调用时并没有调用函数这个过程的汇编指令。

内联函数的特性

1. inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用。缺陷：可能会使目标文件变大，优势：少了调用开销，提高程序运
   行效率。

2. inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不是递归、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。下图为《C++prime》第五版关于inline的建议：
   

3. inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。

面试题：

宏的优缺点？
优点：
1.增强代码的复用性。
2.提高性能。
缺点：
1.不方便调试宏。（因为预编译阶段进行了替换）
2.导致代码可读性差，可维护性差，容易误用。
3.没有类型安全的检查 。

C++有哪些技术替代宏？

1. 常量定义 换用const enum
2. 短小函数定义 换用内联函数