C++中的引用的补充丶内联函数丶auto和nullptr的基础用法

一. 引用的补充以及引用和指针的区别

1. 引用可能会造成权限放大

引用造成隐式的权限放大，原因是引用了具有常属性(const)的临时变量。

我们知道在进行类型转换和运算时都会生成临时变量，该临时变量是编译器隐式生成的，不是我们自己显示生成的。

比如在类型转换的时候：

double d = 12.34;
int i = d;

这里内部的过程是这样的：
· 首先编译器会根据d的值和i的类型产生一个i类型的临时变量(我们暂时称它为temp，它是const int类型的，经过d截断生成的)；
· 其次该临时变量被赋值给i，代码语句如:int i = temp；

那么当类型转换涉及引用时会如何呢？

double d = 12.34;
int& m = d;

首先，当把这两条代码放进VS2022里的时候，它会报错：

我们回顾上面类型转换时内部的过程：
· 生成了一个const int temp，然后int& m = temp；
这很明显出错了，因为变量引用不能接受常量，否则会造成权限放大；

正确的方式：

double d = 12.34;
const int& m = d;

同样的，在进行运算时：

int x = 0, y = 1;
//int& r2 = x + y;		//不行
const int& r2 = x + y;	//可行

---

2. 引用和指针的区别

1. 引用和指针的底层

·语法上，引用是不开辟空间的，而指针是开辟空间的；
·底层上，引用和指针都需要开辟内层空间，引用的底层是一种指针；

我们通过VS2022的反汇编来查看底层中指针和引用机器指令：

int a = 0;
int& b = a;
int* p = &a;

汇编指令：

很明显，指针和引用在底层的机器码中都开辟了内存。

2. 没有NULL引用，但是有NULL指针(相对而言的)

首先先来看一段代码：

//下面代码是否会报错？
int* ptr = NULL;
int& r = *ptr;

这里看似空指针被解引用，然后引用了该值。

但是这里代码是可以正常不报错运行的。

先不解释NULL的解引用，先来说引用为空内容的情况

引用要求引用一块有效内容，根据引用来操作该内容的数据。不同于指针可以指向空，引用为空内容是没有意义的，所以将“没有NULL引用，但是有NULL指针”。

这里我们解释一下上面NULL的解引用。

首先我们知道，NULL值是不能被解引用的。这里却可以正常运行，那么它到底有没有被解引用呢？

我们转到反汇编看一下：

注意：底层这里并没有真正地将指针进行解引用，只是单纯地传递值。

3. 引用和指针不同点的总结

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

二. 内联函数

1.内联函数出现的原因

在内联函数未出现前，C语言使用函数替换的是宏函数。

宏函数在编写时极易出现问题，比如我们写一个ADD宏函数：

// 写一个两表达式相加的宏函数
//错误写法：
#define ADD(int a, int b) return a + b;
#define ADD(a, b) a + b;
#define ADD(a, b) (a + b)
//正确写法
#define ADD(a, b) ((a) + (b))

#define ADD(a, b) ((a) + (b))

1.内层括号确保表达式被传递的优先级
2.外层括号确保后面是一个整体
3.不加分号是因为宏函数的本质是替换 ,加了分号相当于被替换中也含有分号

#define ADD(a, b) ((a) + (b))

#include <iostream>

using namespace std;

int main()
{
	int ret = ADD(1, 2);
	cout << ADD(1, 2) << endl;	// 3
	int x = 1, y = 2;
	ADD(x & y, x | y);  
	
	return 0;
}

如果内部括号没有的话，那么执行：
ADD(x & y, x | y);
这条语句时就会出现问题。

因为&和|的优先级都比+低，那么表达式就会被替换未 （x & y + x | y），这时会先算中间的x+y，而这不是我们想要的结果。

从上面可以看出来，宏函数的编写诸多不便，而且极易出错。

于是在C++中出现了新的替换函数：内联函数

2. 内联函数的特性

1. 本质是一种空间换时间的做法

inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用；

• 缺陷：可能会使得目标文件变大；
• 优势：少了调用开销，提高运行效率。

普通的函数在调用是会建立栈帧，根据函数地址调用函数；而内联函数是在调用处直接展开，没有函数调用建立栈帧的开销，也不会出现宏函数类似的问题。

2. inline对于编译器来说只是一个建议

inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)丶不是递归丶而且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。
在《C++prime》第五版关于inline的建议：
· 内联说明只是向编译器发出的一个请求，编译器可以选择忽略这个请求。

利用反汇编查看底层是如何展开的：

#include <iostream>

using namespace std;
 
inline int Add(int a, int b)
{
	int ret = a + b;
	return a + b;
}

int main()
{
	int c = Add(1, 2);
	cout << c << endl;
	return 0;
}

  int c = Add(1, 2); 处的汇编指令：

可以看出，这里并没有call(函数调用)，而是直接展开，执行函数体内的代码对应的汇编指令。

3.内联函数不建议声明和定义分离

inline不建议声明和定义分离，分离会导致链接错误。因为inline在调用处被展开，而展开处没有函数实体定义，更不会有函数地址，链接就会找不到函数定义而报错。

内联函数在编写时不要声明和定义分离，内联函数直接在.h文件定义就可以。

4. 内联和宏的总结

C++通常用两种技术替代宏：

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

宏的优缺点：

优点：

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

三. auto关键字

auto 用于自动类型推导

• 格式：auto 变量名 = 某标识符
• 形如：auto i = 2；(auto将自动推导为int类型)

注意：在使用auto应用于自动类型推导时，必须要在定义时初始化。

示例代码如下：

#include <iostream>

using namespace std;

typedef char* pstring;
//auto 作为自动类型推导
int main()
{
	int a = 0;
	//auto b;			//编译不通过 使用auto定义变量时必须要对其进行初始化
	auto c = a;		//编译通过
	//const int i;		//编译不通过 i为常属性 需要初始化
	const pstring* p2;
	//const pstring p1;   //相当于char* const p1 此时编译不通过 
						//因为p1为常属性 需要初始化
	return 0;
}

---

1. 使用auto的注意事项

1.当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器会报错

因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。

代码示例：

void TestAuto()
{
	auto a = 1, b = 2;
	auto c = 3, d = 4.0; 	//d = 4.0会编译前报错 
	//因为c和d的初始化类型不同
	//编译器只对第一个类型进行推导 推出int 而int不是d的类型 
}

---

2. auto不能当作形参类型

void TestAuto(auto a)//此处代码编译前报错
//因为编译器无法对a的实际类型进行推导
{
	//do nothing	
}

3. auto不能直接用来声明数组

void TestAuto()
{
	int a[] = { 1,2,3 };
	auto b[] = { 4, 5, 6 };	//编译前出错
}

2. auto推导的情况

直接上代码：

//auto的推导情况
#include <iostream>

using namespace std;

int main()
{
	int x = 10;
	//auto可传普通也可传指针
	auto a1 = x;
	auto a2 = &x;
	//auto* 指定必须时指针
	auto* b = &x;
	//引用
	auto& c = x;

	return 0;
}

3. C++11中的范围for

//可以使用auto自动推导数组类型
#include <iostream>

using namespace std;

int main()
{
	int array[10] = { 1,2,3,4,5,6,7,8,9,10 };
	//自动取出数组array中的数据依此赋值给e
	//自动进行迭代，自动判断结束
	for (auto e : array)
	{
		cout << e << " ";
	}
	//指明类型也可以  但是需要跟array中的元素的类型对应
	for (int e : array)
	{
		cout << e << " ";
	}
	cout << endl;
	return 0;
	
}

//不支持下面这种写法   
void Test(int array[])
{
	for (auto& e : array)
		cout << e << endl;
}

4. typeid可获取数据的类型

格式：typeid(数据).name() 获得一个 (const char)的字符串*

代码示例如下：

#include <iostream>

using namespace std;

int TestAuto()
{
	return 10;
}

int main()
{
	int a = 10;
	auto b = a;
	auto c = 'a';
	auto d = TestAuto();

	cout << typeid(b).name() << endl;	//int
	cout << typeid(c).name() << endl;	//char
	cout << typeid(d).name() << endl;	//int 

	return 0;
}

---

四 . NULL和nullptr

1. NULL的缺陷

NULL实际上是一个宏。
在传统的C头文件stdef.h中，它是大致这样被定义的：

#define NULL 0
#define NULL ((void *)0)

---

但是这样是有缺陷的，比如运行如下代码时：

#include <iostream>

using namespace std;

void f(int)
{
	cout << "f(int)" << endl;
}

void f(int*)
{
	cout << "f(int*)" << endl;
}

int main()
{
	//表面上看 f(0)应匹配f(int);f(NULL)应匹配f(int*)
	f(0);		//实际上0和NULL都会匹配到f(int)  这是因为NULL是由宏定义的0
	f(NULL);	
	f((int*)NULL);
	//而C++的新关键字nullptr不会有这样的问题
	f(nullptr); //调用f(int*)
	return 0;//调用f(int*)
}

注意：宏定义的替换是在预处理阶段由预处理器来进行的。

2. 关键字nullptr

为了解决NULL这种问题 C++引入了关键字nullptr:

• 1.在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++作为新关键字引入的
• 2.在C++11中，sizeof(nullptr)于sizeof((void*)0)所占的字节数相同
• 3.为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr

---

本博客仅供个人参考，如有错误请多多包含。

---

Aruinsches-C++日志-4/2/2024

---