【c➡️c++】打开c++学习之门2——内联函数-auto-空值(nullptr)

🍭内联函数

🕶️概念

🕶️特性：

👉auto关键字(C++11)

➡️类型别名思考

➡️ auto简介

➡️auto的使用细则

➡️auto不能推导的场景

🌈基于范围的for循环(C++11)

🚩范围for的语法

🚩范围for的使用条件

🎈指针空值nullptr(C++11)

🔑C++98中的指针空值

🍭内联函数

🕶️概念

我们在C语言的预处理那一章也有比较详细的学习过宏，也分析了宏的缺点：

当然宏也是有一些优点的：

宏函数语法———1.不需要类型，是一种替换，2.不需要用return ，3.不需要分号

宏函数优势———1.不需要建立栈帧，提高调用效率 2.修改相较容易

宏函数缺点———1复杂，2.容易出错，3.可读性差，4.不能调试

补充：C++中建议用const和枚举enum代替宏定义的常量

从宏的这些优缺点出发，C++又引入了一个新的概念——内联函数。

以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数调用建立栈帧的开销，内联函数提升程序运行的效率。

🕶️特性：

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

既然内联函数优点这么多，那么就可以任何情况下都使用内联函数？

但是适用的场景——短小频繁调用的函数

可执行程序变大，会使程序的内存增大，无法满足使用。

inline对于编译器仅仅只是一个建议，最终是否成为inline，编译器自己决定

2. inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同

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

//像类似函数就加了inline也将会被编译器否决掉

1.比较长的函数

2.递归函数

我们看看上述函数编译器是否可以支持内联函数？

看见call说明编译器不支持

1. 在release模式下，查看编译器生成的汇编代码中是否存在call Add

2. 在debug模式下，需要对编译器进行设置，否则不会展开(因为debug模式下，编译器默认不会对代码进行优化，以下给出vs2013的设置方式)

设置完之后就看不见call Add了，说明已经展开。

如果代码长，编译器就不支持内联函数，代码容量膨胀，说明可执行程序增大

调用函数中的代码量少，没有显示call的，表示编译器可以支持内联函数

稍微长的代码，编译器就禁止掉。

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

宏的优缺点？

优点：

1.增强代码的复用性。

2.提高性能。

缺点：

1.不方便调试宏。（因为预编译阶段进行了替换）

2.导致代码可读性差，可维护性差，容易误用。

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

1. 常量定义换用const enum

2. 短小函数定义换用内联函数

👉auto关键字(C++11)

➡️类型别名思考

typeid(变量).name()——可以打印出该变量的类型

随着程序越来越复杂，程序中用到的类型也越来越复杂，经常体现在：

1. 类型难于拼写

2. 含义不明确导致容易出错

比如：

这个std::map<std::string,std::string>::iterator就是一个类型，现在我们还看不懂，还没学到。
这个类型就很长，我们写的时候就很容易可能会写错，怎么简化呢？
大家可能会想到用typedef去取一个别名。
这确实是一个方法。

使用typedef给类型取别名确实可以简化代码，但是typedef也存在一些不好的地方。比如：

使用typedef给类型取别名确实可以简化代码，但是typedef也存在一些不好的地方。比如：
typedef char* pstring;
int main()
{
	const pstring p1;    // 编译成功还是失败？
	const pstring* p2;   // 编译成功还是失败？
	return 0;
}

大家看定义这两个变量有没有什么问题？

🆗，p1这里有错误，为什么呢？
我们自己分析肯定认为p1是这样的？
const char* p1
那这肯定没什么问题嘛，p1是一个字符指针，const 修饰*p1，那就是p1指向的内容不能被改变罢了。
但是，由于这里typedef char* pstring;的缘故，实际上是这样的：
char* const p1；
即const修饰p1，p1不能被修改，而const修饰的变量是必须初始化的，但这里我们没初始化，所以就报错了。

初始p1即可。

在编程时，常常需要把表达式的值赋值给变量，这就要求在声明变量的时候清楚地知道表达式的类型。然而有时候要做到这点并非那么容易，因此C++11 给 auto 赋予了新的含义。

➡️ auto简介

在早期 C/C++ 中 auto 的含义是：使用 auto 修饰的变量，是具有自动存储器的局部变量，但遗憾的是一直没有人去使用它，大家可思考下为什么？

C++11 中，标准委员会赋予了 auto 全新的含义即：

auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得

定义一个整型变量a，变量b要想接收a，也应该定义成int类型，这没什么问题。
但是，现在我们就可以这样写：

那这时b的类型就不是我们显示指定的，而是根据a自动推导出来的。
当然，其它类型的数据也可以：

auto根据右边的表达式自动推导左边变量的类型

typeid(变量).name()——可以打印出该变量的类型

int main()
{
	int a = 0;
	int b = 10;
	auto c = a;
	auto d = 1 + 1.1;
	cout << typeid(c).name() << endl;
	cout << typeid(d).name() << endl;
	return 0;
}

使用auto定义变量时必须对其进行初始化

C++11引入了auto关键字，使得程序员可以使用类型推导的方式定义变量，让编译器自动推断变量的类型。它的语法形式为：

auto variable = value;

其中，variable为变量名，value为变量的初始值，编译器会根据value的类型推导出variable的类型。

auto关键字的使用可以使代码更加简洁、易读、易维护，同时也方便定义一些复杂类型的变量，例如迭代器、函数返回值等。

【注意】⚠：

使用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto的实际类型。因此auto并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编译期会将auto替换为变量实际的类型。

➡️auto的使用细则

1. auto与指针和引用结合起来使用

用 auto 声明指针类型时，用 auto 和 auto* 没有任何区别，但用 auto 声明引用类型时则必须加 &

int main()
{
	int x = 10;
	auto a = &x;
	auto* b = &x;
	auto& c = x;
	cout << typeid(a).name() << endl;
	cout << typeid(b).name() << endl;
	cout << typeid(c).name() << endl;
	*a = 20;
	*b = 30;
	c = 40;
	return 0;
}

2.在同一行定义多个变量

当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量

void TestAuto()
{
	auto a = 1, b = 2;
	auto c = 3, d = 4.0; // 该行代码会编译失败，因为c和d的初始化表达式类型不同
}

➡️auto不能推导的场景

1. auto不能作为函数的参数

// 此处代码编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导
void TestAuto(auto a)
{}

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

//此处代码错误
void TestAuto()
{
 int a[] = {1,2,3};
 auto b[] = {4，5，6};
}

🌈基于范围的for循环(C++11)

🚩范围for的语法

在 C++98 中如果要遍历一个数组，可以按照以下方式进行：

void TestFor()
{
 int array[] = { 1, 2, 3, 4, 5 };
 for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
 array[i] *= 2;
 
 for (int* p = array; p < array + sizeof(array)/ sizeof(array[0]); ++p)
 cout << *p << endl;
}

对于一个 有范围的集合 而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因此 C++11 中引入了基于范围的for 循环。

for 循环后的括号由 冒号“ ：” 分为两部分：

第一部分是范围内用于迭代的变量，
第二部分则表示被迭代的范围。

我们上面说了，它是把数组的元素赋值给了前面的遍历i和e，i和e相当于是数组元素的拷贝，所以我们改变i的值，并不会影响数组元素的值。

这样它会自动取数组中的元素赋给e变量，并自动判断结束。

注意：与普通循环类似，可以用 continue 来结束本次循环，也可以用 break 来跳出整个环 。

🚩范围for的使用条件

1. for循环迭代的范围必须是确定的

对于数组而言，就是数组中第一个元素和最后一个元素的范围 ；对于类而言，应该提供 begin 和 end 的方法，begin 和 end 就是 for 循环迭代的范围。

注意：以下代码就有问题，因为 for 的范围不确定

void TestFor(int array[])
{
 for(auto& e : array)
 cout<< e <<endl;
}

这里我们能看出来是数组传参，数组传参我们指的其实是传的首元素地址，这里虽然用数组接收，但其本质上还是个指针。

🎈指针空值nullptr(C++11)

🔑C++98中的指针空值

在良好的 C/C++ 编程习惯中，声明一个变量时最好给该变量一个合适的初始值，否则可能会出现不可预料的错误，比如未初始化的指针。

如果一个指针没有合法的指向，我们基本都是按照如下方式对其进行初始化：
int* p1 = NULL;

NULL就是空指针嘛，我们学过C语言知道其实NULL就是把0强制类型转换为void*的指针了，实际是一个宏

void f(int)
{
 cout<<"f(int)"<<endl;
}
void f(int*)
{
 cout<<"f(int*)"<<endl;
}
int main()
{
 f(0);
 f(NULL);
 f((int*)NULL);
 return 0;
}

NULL不是指针嘛，为什么f(NULL);调用的也是第一个函数呢？
原因在于NULL在C++ 中的定义发生了一些改变。

NULL实际是一个宏，在传统的C头文件(stddef.h)中，可以看到如下代码：

意思呢就是在C++中NULL其实就是0。

所以要想NULL调用第二个函数

在C++98中，字面常量0既可以是一个整形数字，也可以是无类型的指针(void*)常量，但是编译器默认情况下将其看成是一个整形常量，如果要将其按照指针方式来使用，必须对其进行强转。

那由于以上这些原因呢，C++11引入了一个新关键字nullptr来表示空指针：

注意：

1. 在使用 nullptr 表示指针空值时，不需要包含头文件，因为 nullptr 是 C++11 作为新关键字引入的 。

2. 在 C++11 中， sizeof(nullptr) 与 sizeof((void*)0) 所占的字节数相同。

3. 为了提高代码的健壮性，在后续表示指针空值时建议最好使用 nullptr 。