《C++要笑着学》|【C++要笑着学】内联函数 | 关键字auto | 范围for | 关键字 nullptr 《C++要笑着学》|c++

火速猛戳订阅《C++要笑着学》趣味教学博客

文章图片

写在前面：本章将继续讲解C++入门部分的知识，将对内联函数、改版后的auto关键字、范围for，以及指针空值nullptr 等知识点进行讲解。

Ⅰ.内联函数 0x00 问题引入

文章图片
调用函数，需要建立栈帧，栈帧中要保留一些寄存器，结束后又要恢复。
这就可以看出这些都是有消耗的，对于频繁调用的小函数，有没有方法可以优化呢？
比如下面这个两数相加的函数：

int Add (int x,int y) { int ret = x + y; return ret; }

我们可以写一个两数相加的宏：

#include using namespace std; int Add(int x, int y) { int ret = x + y; return ret; }// 写一个两数相加的宏 #define ADD(X, Y) ((X) + (Y))int main(void) { cout << "函数: " << Add(1, 2) << endl; cout << "宏: " << ADD(1, 2) << endl; // 写宏的技巧：记住宏原理是替换，你替换一下看看对不对 // cout << "M: " << ((1) + (2)) << endl; cout << "宏: " << 10 * ADD(3, 4) << endl; return 0; }

运行结果如下：

《C++要笑着学》|【C++要笑着学】内联函数 | 关键字auto | 范围for | 关键字 nullptr

文章图片

0x01 内联函数的概念

文章图片
宏有时候用起来似乎比较复杂，也容易出错。我们可以使用C++中的内联函数来解决。
概念：以 inline 修饰的函数叫做内联函数。
语法：inline 数据类型 [函数名]

代码演示：

#include using namespace std; inline int Add(int x, int y) { int ret = x + y; return ret; }int main(void) { cout << "内联函数: " << Add(1, 2) << endl; return 0; }

0x02 内联函数的特性

文章图片
特性：以时间换空间，省去了调用函数的开销。
编译时 C++ 编译器会在调用内联函数的地方展开，是没有函数压栈的开销的。

因为他会在编译的时候展开，所以代码很长。举个例子：

inline void func() { // 假设有10行代码 }

如果不展开，假设有1000个调用，编译后台就会有 10 + 1000 条指令。
如果展开，编译后台合计会有 10 * 1000 条指令，
所以，这是一场以时间换取空间的交易。

文章图片
因为没有了函数压栈的开销，所以能提高程序运行的效率。

注意事项：
① inline 既然是以时间换空间的做法，所以代码很长、循环或递归的函数不适宜成为内联函数。
②inline 对于编译器而言只是一个建议，编译器会自动优化，如果定义为 inline 函数的函数体内油循环或递归等等，编译器优化时会忽略掉内联。
③ inline 申明和定义不建议分离。内联函数会认为在调用的地方展开，导致不生成地址。test.cpp -> test.o符号表中不会生成 Func 函数的地址，因为 inline 函数是不需要地址的（都在调用的地方展开了还要个毛线地址）。我们来验证一下：
Add.h：

#include using namespace std; inline int Func(int x, int y);

Add.cpp：

#define _CRT_SECURE_NO_WARNINGS 1 #include "Add.h"int Func(int x, int y) { return x + y; }

test.cpp：

#include "Add.h"int main(void) { Func(1, 2); return 0; }

运行结果如下：

文章图片

0x03 浅谈宏的优缺点和替代方法

文章图片

? 宏的优缺点是什么？
优点：
① 宏可以增强代码的复用性
② 宏有助于提高性能
缺点：
① 宏调试起来很不方便（因为宏在程序预编译阶段进行替换）。
② 宏的大量使用可能会导致代码的可读性差，可维护性差，容易误用。
③ 宏没有类型安全的检查。

有哪些技术可以替代宏？
① 常量定义：换用 const
② 函数定义：换用内联函数

Ⅱ.auto关键字（C++11） 0x00 改版前的auto
改版前的 auto 指的是在早期 C/C++ 中 auto 关键字的含义。
旧的含义：使用 auto 修饰的变量，是具有自动存储器的局部变量。

文章图片
遗憾的是，大家都懒得去用它。这是为什么呢？

auto int a = 0; // 表示a是一个自动存储类型，会在函数结束后自动销毁。

当使用 auto 修饰后，表示 a 是一个自动存储类型，它会在函数结束以后自动销毁。
但是因为后来 C 把标准给改了，不加是自动销毁：

int a = 0; // 标准改了之后，不加也是自动销毁。

文章图片
这么一来，这个 auto 关键字就没有意义了，因为都是自动销毁。
auto：这就尴尬了，我的存在没有意义了，用和不用都一样。

0x01 改版后的auto
C++标准委员会觉得这 auto 也太尴尬了，我们得给它来一波加强。
为了缓解 auto 的尴尬，C++ 标准委员会把 auto 原来的功能给废弃了。
并赋予了 auto 全新的含义！

文章图片

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

也就是说，它可以自动推导出数据的类型：

int a = 0; auto c = a; // C++11给auto关键字赋予了新的意义：自动推导c的类型

你的右边是什么，它就会推导出相应的类型
任何类型都可以实现，包括但不限于：

auto ch = 'A'; auto e = 10.11; auto pa = &a;

为了方便测试，我们来打印一下对象的类型看看：

#include using namespace std; int main() { int a = 0; auto c = a; // 自动推导c的类型auto ch = 'A'; auto e = 10.11; auto pa = &a; // typeid - 打印对象的类型 cout << typeid(c).name() << endl; // i cout << typeid(ch).name() << endl; // c cout << typeid(e).name() << endl; // d cout << typeid(pa).name() << endl; // Pireturn 0; }

运行结果如下：

文章图片
emmm... 确实

文章图片
这时候可能有人会觉得，这一波操作好像也没啥意义啊，
直接写数据类型不香吗？int c = a;
我们继续往下看~

0x02 auto 的使用场景

文章图片

处理又臭又长的数据类型
遇到这种场景，就能体会到 auto 的香了：

#include #include int main(void) { std::map dict = {{"sort", "排序"}, {"insert", "插入"}}; std::map::iterator it = dict.begin(); // 这个类型又臭又长，写起来太麻烦了。。。auto it = dict.begin(); // 可以改成这样，爽！ // ↑ 根据右边的返回值去自动推导it的类型，写起来就方便多了return 0; }

像遇到这种又臭又长的类型，而且还要经常使用，
这时候使用 auto 帮你自动推到类型，就很爽了！

auto 与指针结合起来使用：
auto 非常聪明，它在推导的时候其实是非常灵活的：

int main(void) { int x = 10; auto a = &x; // int* auto* b = &x; // int* auto& c = x; // intreturn 0; }

在同一行定义多个变量

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

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

0x03 使用auto的注意事项

文章图片
注意！
使用 auto 是必须要给值的！

int i = 0; auto j; ?auto j = i; 必须给值！！

这就意味着，auto 是不能做参数的！

auto 不能作为函数的参数

void TestAuto(auto a); ?

此处代码编译失败，auto 不能作为形参类型，因为编译器无法对a的类型进行推导！

auto 不能直接用来声明数组

auto b[3] = {4,5,6}; ?

为了避免与 C++98 中的 auto 发生混淆，C++11 只保留了 auto 作为类型指示符的用法。

文章图片
auto 在实际中最常见的优势用法就是 C++11 提供的新式 for 循环，还有 lambda 表达式等进行配合使用。我们可以继续往下看~

Ⅲ.范围 for（C++11） 0x00 概念
范围 for，即 —— 基于范围的 for 循环。

文章图片
范围for可以说是一颗 "语法糖" ，什么是语法糖？
就是用起来会让人觉得很甜，很爽的东西~

以前，我们要遍历一个数组，一般会按照以下方式进行：

int main() { int arr[] = { 1, 2,3,4,5 }; int sz = sizeof(arr) / sizeof(arr[0]); // 计算数组大小int i = 0; for (i = 0; i < sz; i++) { printf("%d ", arr[i]); } printf("\n"); return 0; }

文章图片
对于一个有范围的集合而言，让程序员来说明循环的范围是多余的，
有时候还会容易犯错误……

文章图片
因此，C++11中引入了基于范围的 for 循环。

语法： for ( auto 变量名 : 数组)
for 循环后的括号由冒号分为两部分：
第一部分：范围内用于迭代的变量
第二部分：表示被迭代的范围

0x01 范围 for 的用法

文章图片

使用方法演示：

int main() { int arr[] = { 1, 2, 3, 4, 5 }; for (auto e : arr) { printf("%d ", e); } printf("\n"); return 0; }

运行结果如下：

文章图片

试着使用范围 for，把数组中的每个值 +1（1 2 3 4 5 → 2 3 4 5 6）

#include using namespace std; int main() { int arr[] = { 1, 2, 3, 4, 5 }; // ++ for (auto& e : arr) { e++; }// 打印 for (auto e : arr) { cout << e << " "; } cout << endl; return 0; }

运行结果如下：

文章图片

解读：这里我们可以使用引用来对数组中的每个值进行修改。

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

0x01 范围 for 的使用条件
for 循环迭代的范围必须是确定的

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

? 错误演示：下面的代码就是 for 循环范围不确定！

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

这里传递过来的是数组的首元素地址，并不是数组，它会不知道范围是多少，所以会报错。

迭代的对象要实现 ++ 和 == 的操作

文章图片
（关于迭代器这个问题，后期会讲，现在了解一下留个印象即可）

Ⅳ.指针空值 nullptr 0x00 C++ 98 中的指针空值
【《C++要笑着学》|【C++要笑着学】内联函数 | 关键字auto | 范围for | 关键字 nullptr】

文章图片

在良好的 C/C++ 变成习惯中，声明一个变量时最好给该变量一个合适的初始值，否则可能会出现不可预料的错误，比如未初始化的指针。
如果一个指针没有合法的指向，我们就需要手动给它置为空。
在之前的C语言教程里，我们都是用 NULL 来解决的：

#include using namespace std; int main(void) { // C++ 98/03 int* p1 = NULL; int* p2 = 0; return 0; }

这里的 NULL 其实是一个宏。

C++ 空指针推荐使用 nullptr 来处理

int* p3 = nullptr;

这是 C++11 新增的关键字，以后就不再推荐使用 NULL 了。

注意事项
① 使用 nullptr 表示指针空值时，因为它是关键字，所以不需要包含头文件。
② C++11中，sizeof( nullptr ) 与 sizeof( (void*)0 ) 所占的字节数相同。
③ 为了提高代码的健壮性，在后续表示指针空值的时建议最好使用 nullptr 。

0x01 引入 nullptr 的原因
正如之前所说，NULL 其实是一个宏：
我们打开传统的 C 头文件（stddef.h）中可以看到如下代码：

#ifndef NULL #ifdef __cplusplus #define NULL 0 #else #define NULL ((void *)0) #endif #endif

可以看到，NULL可能被定义为字面常量0，或者被定义为无类型指针 (void*) 的常量。
不论采取何种定义，在使用空值和指针时，都不可避免地会遇到一些麻烦，比如：

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

该程序的本意是想通过 Func(NULL) 调用指针版本的 Func(int*) 函数，但是由于 NULL 被定义成0，这么一来就不符合程序的初衷了。
在C++98中，字面常量 0 既可以是一个整型数字，也可以是无类型的指针 (void*) 常量，但是编译器默认情况下会将其看成一个整型常量，如果要将其按照指针方式来使用，必须对其进行强制类型转换 (void*)0 。

文章图片
后来C++11引入了指针空值 nullptr 就缓解了这一尴尬现象。
总结：nullptr 其实就是 0，所以有了 C++11之后，就不再推荐大家使用 NULL 了。

参考资料：
Microsoft. MSDN(Microsoft Developer Network)[EB/OL]. []. .
百度百科[EB/OL]. []. https://baike.baidu.com/.
比特科技. C++[EB/OL]. 2021[2021.8.31]. .
程序员面试宝典[M]. 5. .