👑作者主页：@安度因
🏠学习社区：StackFrame
📖专栏链接：C++修炼之路

文章目录

一、前言
二、内联函数
- 1、概念
- 2、特性
三、auto（C++ 11)
- 1、概念
- 2、价值
- 3、三个不能
四、范围for循环(C++11)
- 1、基本使用
- 2、使用条件
五、指针空值nullptr(C++11)
六、结语

如果无聊的话，就来逛逛我的博客栈吧! 🌹

一、前言

大家好，我是 $an d u in$ . 这篇文章是 C++ 入门的最后一篇。内容主要为 内联函数、auto、范围 for 循环和 nullptr 空指针 ，对于后三个都是 C++11 的特性。内容不多，也不难，让我们开始学习吧！

二、内联函数

调用函数需要建立栈帧，栈帧中要保存寄存器，结束后就要恢复，这其中都是有消耗的：

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

int main()
{
	add(1, 2);
	add(1, 2);
	add(1, 2);
	add(1, 2);
	add(1, 2);

	return 0;
}

而针对 频繁调用 的 小函数，可以用宏优化，因为宏是在预处理阶段完成替换的，并没有执行时的开销，并且因为代码量小，也不会造成代码堆积。

例如，代码就可以写成这样：

#define ADD(x, y) ((x) + (y)) 

int main()
{
	cout << ADD(1, 2) << endl;

	return 0;
}

但是宏也有缺点：

不能调试
没有类型安全的检查
有些场景下非常复杂

就拿 add 函数来说，可能一不小心就会写成 #define ADD(x + y) x + y 的样子；所以写宏时出错，要么是替换出错，要么是因为优先级出错，所以宏并不友好。

而 C++ 针对为了减少函数调用开销，又可以在一定程度上替代宏，避免宏的出错，从而设计出了内联函数 。

内联函数的关键字为 inline ：

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

int main()
{
	int ret = add(1, 2);
	cout << ret << endl;

	return 0;
}

1、概念

在 release 版本下，inline 内联函数会直接在调用部分展开；对于 debug 则需要 主动设置 (debug 下编译器默认不对代码做优化)；但是 release 版本下其他版本优化的太多，可能就不太好观察，所以我们设置一下编译器，在 debug 下看：

打开解决方案资源管理器，右击项目名称，选中属性并打开，在 C/C++ 区域常规部分，在调试信息一栏设置格式为程序数据库：

在 C/C++ 优化一栏，将内联函数扩展部分选中只适用于 _inline ：

设置完毕后，点击应用。

在设置前、后，分别启动调试，查看反汇编代码：

修改前：

修改后：

两段反汇编代码最大的区别就是 call 消失了 ，call 就是函数调用的指令，它的消失就说明第二段代码没有进行调用。内联函数直接在局部展开了，在 main 函数中完成了操作。有了内联，我们就不需要去用 c 的宏了，因为宏很容易出错。

2、特性

inline是一种以 空间换时间 的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用，缺陷：可能会使目标文件变大，优势：少了调用开销，提高程序运行效率。
inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不是递归、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。下图为《C++prime》第五版关于inline的建议：

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

要点讲解：

1）空间换时间是因为反复调用内联函数，导致编译出来的可执行程序变大

inline void func()
{
    // 假设编译完成为 10 条指令
}

若不用内联函数，不展开，若1000次调用 func，每次调用的地方为 call 指令的形式，总计 1010 行指令。若用内联函数，则展开，若一千次调用，每次调用的地方为都会展开为 10 条指令，总计 10 * 1000 行指令。

展开会让编译后的程序变大，如果递归函数作内联，后果可想而知。所以长函数和递归函数不适合展开。

2）编译器可以忽略内联请求，内联函数被忽略的界限没有被规定，一般10行以上就被认为是长函数，当然不同的编译器不同

基于上面的解释，所以编译器会决策是否使用内联函数。因为如果函数太大导致的结果很糟糕。

3）内联函数声明和定义不可分离

// F.h
#include <iostream>
using namespace std;
inline void f(int i);
// F.cpp
#include "F.h"
void f(int i)
{
	cout << i << endl;
}
// main.cpp
#include "F.h"
int main()
{
	f(10);
	return 0;
}
// 链接错误：main.obj : error LNK2019: 无法解析的外部符号 "void __cdecl
f(int)" (?f@@YAXH@Z)，该符号在函数 _main 中被引用

由于内联函数在调用的地方展开，所以内联函数无地址（这里的地址指的是call 指令调用函数的地址，通过这个地址会跳到 jmp 指令处，再根据 jmp 处指令跳转到函数执行的部分） ，即 f.cpp->f.o 符号表中，不会生成 f 的地址。

当编译时，由于头文件要被包含，但是这时只有函数声明，但是没有函数的定义，所以只能在链接时展开，这里只能变为 call + 地址的指令，但是内联函数并没有地址，链接不到，就报错了。

所以当声明和定义分离，调用函数时，由于内联函数无地址，编译器链接不到，所以就会报错，为链接错误。

结论：简短，频繁调用的小函数建议定义成 inline .

三、auto（C++ 11)

1、概念

在 c 语言中，也存在 auto 关键字。

int main()
{
    auto int a = 0;
}

auto 关键字修饰后，a变为自动存储类型，即变量会在函数结束以后自动销毁。但是这个语法完全多此一举，因为后来，对于局部变量默认就是自动存储类型，当函数结束后也会自动销毁。

于是 C++ 委员会废弃了 auto 的用法，赋予了新的意义：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。

int main()
{
	int a = 0;
	int b = 0;
	auto c = a; // 自动推导 c 的类型
	auto d = 'A';
	auto e = 10.11;

	return 0;
}

auto 会自动推导变量的类型。

typeid 可以看对象类型，用法为 typeid(c).name() ，由此可以打印变量的类型：

对于 auto 来说，并不会保留 const 属性，例如 e ，10.11 是常量，就丢弃了 const 属性，而保留 double .

对于 auto ，如果要加上 const 属性，则需要主动加上：

int main()
{
	int x = 10;
	const auto y = x;
	cout << typeid(y).name() << endl; // 这里不会打印出，需要调试看

	return 0;
}

2、价值

auto 具有两种针对场景：

类型难于拼写
含义不明确导致容易出错

上面的使用仅仅是样例，而它真正的价值体现在 stl 部分 和 范围遍历 中。

在 stl 中，有些类型名字很长，例如：

#include <map>

int main()
{
	map<string, string> dict;
	map<string, string>::iterator it = dict.begin();

	return 0;
}

当要取其迭代器进行遍历时，很复杂，这时 auto 就派上用场了。

auto it = dick.begin();

它会根据右边的返回值类型，自动推导 it 的类型，写起来十分方便。

对于这里使用 typedef 进行重命名也可以 ：

int main()
{
	map<string, string> dict;
	typedef map<string, string>::iterator Dict;
	Dict it = dict.begin();

	return 0;
}

虽然 typedef 可以使用，但是 typedef 有一个缺点，看这个例子：

p1 是失败的 ：

因为 typedef 这里不是展开为 const char* p1 ，实际上这里 typedef 之后是 char* const p1 ，const 修饰的是 p1 ，但是 p1 没有初值，之后也改不了了，所以就失败了；但是 p2 展开是 char* const *p2 ，修饰的是 *p2 ，此刻 p2 是能改的，所以没问题。

验证一下：

typedef char* pstring;

int main()
{
	const pstring p1 = nullptr; // 需要一个初值
	const pstring* p2;
}

auto 很灵活，甚至可以在后面附上其他属性，附上属性后，就显示表现它的类型：

auto& c 的意思就是，c 为 x 的别名，但是类型还是 int ，不过显示认为，它就是推导出来类型的别名。

3、三个不能

auto不能独立定义

auto不能作为函数的参数

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

因为编译器无法推导 auto 的类型，没有根据。

auto不能定义数组

void TestAuto()
{
    int a[] = {1,2,3};
    auto b[] = {4，5，6};
}

四、范围for循环(C++11)

1、基本使用

之前对于数组的遍历，需要使用下标遍历：

int main()
{
	int arr[] = { 1, 2, 3, 4,5 };

	for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++) 
	{
		printf("%d ", arr[i]);
	}

	return 0;
}

而 C++ 中效仿新语言，加入了范围遍历：

int main()
{
	int arr[] = { 1, 2, 3, 4,5 };

	for (auto num : arr) 
	{
		cout << num << endl;
	}

	return 0;
}

其中就用到了 auto 关键字，当复杂类型遇到auto和范围遍历，就是天堂。

而范围for循环的原理就是自动取遍历目标的每一个元素，再放到给定的临时变量中。在上方就是取 arr 的元素放到 num 中，并自动判断结束。auto 会根据遍历目标的元素类型自动推导，当然直接写类型 int 也对 。

如果要使用范围遍历修改遍历目标，则可以使用引用 ：

for (auto num : arr) { num ++ ;}

若以这种写法，是不会改变的，因为 num 是局部变量，只是值和 arr 中元素相等，本身并没有关联。

但是如果加上引用，意义就变了：取遍历目标每个元素的值给 num ，让 num 变为那些元素的别名 ：

而对于 num 的生命周期，则可以认为仅在每次范围遍历中（某一次循环）才存在。

范围 for 会根据遍历目标的元素类型来取出元素，例如上方例子就是 int ，如果这时用指针接收，就是错误的：

因为取出来的每一个元素是 int ，类型不匹配。而判断结束我们并不用担心，其实和普通遍历类似。

2、使用条件

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

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

以下代码就有问题，因为for的范围不确定，因为函数传参，数组就会退化为指针：

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

是错误的。

五、指针空值nullptr(C++11)

对于 c 来说，空指针为 NULL，是一个宏。

在 C++98/03 时，只能使用 NULL ；而 C++11 后，推荐使用 nullptr 。

NULL ：

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

实际上 NULL 就是个宏，所以说写成 int* p = 0 ，也可以；而j绝大多数情况下，这样写都没问题。

但是对于极端场景：

void f(int) // 这边由于不使用形参，不给形参名也可以
{
	cout << "f(int)" << endl;
}

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

int main()
{
	f(0);
	f(NULL);
	return 0;
}

按道理，对于第一次调用，应该匹配第一个，对于第二次调用，应该匹配第二个。

但是实际上它们都匹配了第一个，原因是 NULL 是一个宏，本质为 0 .

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

注意点：