一、内联函数

1、前置知识

2、内联函数概念

3、内联函数特性

4、补充内容

4.1、宏的优缺点

4.2、C++有哪些技术替代宏

二、auto关键字(C++11)

1、概念

2、使用场景

3、使用细则

3.1、auto与指针和引用结合起来使用

3.2、在同一行定义多个变量

3.3、auto不能作为函数的参数

3.4、auto不能直接用来声明数组

3.5、补充内容

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

1、范围for的语法

2、范围for的使用条件

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

一、内联函数

1、前置知识

在使用C++编写代码时，我们通常不推荐使用宏函数。因为由于宏函数的使用场景相当多样，所以宏函数的编写也就变的极为复杂，难以掌握。

我们以一个实现两数相加的 ADD 宏函数作为例子进行说明：

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

这个 ADD 宏函数为什么必须要写成这种形式才是正确的呢？写成 ADD(x, y) (x+y) 、 ADD(x,y) (x+y)；、 ADD(x, y) x+y 等形式又错在哪里呢？这些写法在不同的场景下会遇到不同的问题：

ADD(x, y) (x+y) 的局限性：

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

int main()
{
	int a = 1, b = 2;
	ADD(a | b, a & b);

	return 0;
}

当宏函数内的成员是表达式时，会出现优先级的问题，宏函数被替换为了 a | b + a & b 。根据C语言运算符的优先级，加运算的优先级是大于按位与、按位或的优先级的，所以这个宏函数就无法达到我们预期的结果。

ADD(x,y) (x+y)；的局限性：

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

int main()
{
    ADD(1, 2) * 3; //被替换为了 ((1)+(2)); * 3;

	return 0;
}

这种情况下，宏函数替换后直接发生了语法错误。

这还仅仅是一个简单的ADD宏函数，就已经出现了这些各种各样的需要额外注意的情况，如果宏函数实现的功能再复杂一些，那么宏函数的编写就变得过于麻烦了。

但是我们还不能完全舍弃掉宏函数，因为宏函数也有各种各样的优点，比如不需要建立函数栈帧，节省资源等等，所以我们需要一个东西来代替宏函数，那就是内联函数。

2、内联函数概念

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

inline int ADD(int a, int b)
{
	int c = a + b;
	return c;
}

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

	return 0;
}

我们使用反汇编观察一下：

这里还是跳转到 ADD 函数中去了，这是因为编译器在 debug 模式下为了获取调试信息，默认使 inline 不起作用。我们可以在编译器中右键点击工程文件，点击属性做如下修改：

我们再重新进入调试，转到反汇编进行观察：

可以发现已经没有 call 指令了。这说明程序没有给内联函数开辟函数栈帧，节省了空间。

3、内联函数特性

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

需要注意的是，这里的以空间换时间，是指编译出来的可执行程序会变大，占据的是硬盘的空间，而不是内存的。

比我们如有一个 10 行的函数 Swap，程序里有1000个调用 Swap 函数的地方。

如果 Swap 不是内联函数，那么 Swap 函数加上调用 Swap 函数的代码一共是 10 + 1000 行代码。

如果 Swap 是内联函数，那么 Swap 函数加上调用 Swap 函数的代码一共是 10 * 1000 行代码。

ps：这里是粗略计算，事实上内联函数会去掉 Swap 函数建立栈帧等等相关的指令，会比 10 行少。

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

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

// 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 指令来跳转，所以在链接时会因为找不到该函数而产生报错。

解决方法是在头文件里声明函数时，就直接定义该函数。以便在编译阶段可以直接展开头文件，以免链接时发生错误。

4、补充内容

4.1、宏的优缺点

优点：

增强代码的复用性
提高性能

缺点：

不方便调试宏。（因为预编译阶段进行了替换）
导致代码可读性差，可维护性差，容易误用
没有类型安全的检查

4.2、C++有哪些技术替代宏

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

二、auto关键字(C++11)

1、概念

在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量。但因为所谓自动存储就是函数结束（出了作用域），这个变量自动销毁。这样的作用没有意义，因为现在的变量也是出了作用域就自动销毁。所以C++11中，标准委员会赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。

auto 是自适应类型，会自动识别所赋值变量的类型，例如：

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

	return 0;
}

此时， b 的类型就被自动识别成了 int ， c 的类型被自动识别为 char 。

我们可以使用 typeid 来查看变量的类型。语法为 typeid(变量名).name() ：

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

2、使用场景

那这个 auto 有什么用呢？

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

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

例如在使用 stl 里的容器时，有些类型的名字非常长，就会出现这样的场景：

#include <string>
#include <map>
int main()
{
	std::map<std::string, std::string> dict;
	std::map<std::string, std::string>::iterator dit = dict.begin();

	return 0;
}

std::map<std::string, std::string>::iterator 是一个类型，但是该类型太长了，特别容易写错。所以我们就可以使用 auto 来自动识别类型：

auto dit = dict.begin();

也有的人是使用 typedef 来解决这个问题：

#include <string>
#include <map>
int main()
{
	std::map<std::string, std::string> dict;
	typedef std::map<std::string, std::string>::iterator Dict;
	Dict dit = dict.begin();

	return 0;
}

这样的确也可以简化代码，不过 typedef 有一些缺点。比如：

typedef char* pstring;

int main()
{
	const pstring p1;
	const pstring* p2; 
	return 0;
}

在定义 p1 时，出现了报错。

因为把 const pstring p1；展开之后的形式是这样的 char* const p1； const 修饰的是 p1，p1就变为了常变量，所以在定义的时候必须要进行初始化。

把 const pstring* p2；展开后的形式是 char* const *p2； const 修饰的是 *p2，而 p2 是可以改变的，所以没有报错。

3、使用细则

3.1、auto与指针和引用结合起来使用

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

3.2、在同一行定义多个变量

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

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

3.3、auto不能作为函数的参数

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

3.4、auto不能直接用来声明数组

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

3.5、补充内容

1、为了避免与C++98中的auto发生混淆，C++11只保留了auto作为类型指示符的用法。
2、 auto 在实际中最常见的优势用法就是跟以后会讲到的 C++11 提供的新式for循环，还有
lambda表达式等进行配合使用。

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

1、范围for的语法

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

void TestFor()
{
	int array[] = { 1, 2, 3, 4, 5 , 6, 7, 8, 9, 10};
	for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
	{
		cout << array[i] << " ";
	}
    cout << endl;
}

但是对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因此C++11中引入了基于范围的for循环。for循环后的括号由冒号 “ ：” 分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。

void TestFor()
{
	int array[] = { 1, 2, 3, 4, 5 , 6, 7, 8, 9, 10 };
	for (auto x : array)
	{
		cout << x << " ";
	}
    cout << endl;
}

自动依次取出数组中数据赋值给 x 对象，自动判断结束。

因为该语法是取出数组中数据赋值给 x ，所以改变 x 不会改变数组中数据的值。

为了能够改变数组中的值，我们可以使用引用：

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

2、范围for的使用条件

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

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

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

因为函数传递数组时，本质上传递的数组首元素的地址，而这显然不能作为 for 的范围。

类比到旧版 for 循环中代码是这样的：

void TestFor(int array[])
{
	for(int i; i < sizeof(array) / sizeof(int); ++i)
		cout << array[i] << endl;
}

相信大家可以更直观的了解错误出现在哪里。

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

我们在定义一个指针时，一般都会给这个指针赋上一个初值。如果暂时不确定这个指针要指向哪里，我们会把这个指针指向空，写为：

int* a = NULL;

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

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

可以看到，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;
}

发现本来 f(0) 应该被匹配到 f(int) 函数， f(NULL) 应该被匹配到 f(int*) 函数的。结果 f(0) 和 f(NULL) 都匹配到了 f(int) 函数。这就造成了脱离预期的结果。

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

我们把NULL改为使用 nullptr 再来观察一下：

此时就不会再出现这样的错误。

总结：

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

关于C++入门的相关知识就讲到这里，希望同学们多多支持，如果有不对的地方希望大佬指正，谢谢！

【C++】C++ 入门（三）

一、内联函数

1、前置知识

2、内联函数概念

3、内联函数特性

4、补充内容

4.1、宏的优缺点

4.2、C++有哪些技术替代宏

二、auto关键字(C++11)

1、概念

2、使用场景

3、使用细则

3.1、auto与指针和引用结合起来使用

3.2、 在同一行定义多个变量

3.3、auto不能作为函数的参数

3.4、auto不能直接用来声明数组

3.5、补充内容

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

1、范围for的语法

2、范围for的使用条件

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

相关文章

3.2、在同一行定义多个变量