[C++知识库]【C++】C++ 入门

一、第一个C++程序

今天我们正式开始C++语言的学习，和C语言一样，我们与C++的第一缕羁绊从打印 “hello world” 开始：

#include <iostream>

using namespace std;

int main()
{
	cout << "hello world" << endl;
	return 0;
}

我们知道，C++是对C语言的完善以及再发展，所以C++中的很多东西是与C语言十分修饰的，并且C++也是兼容C的，也就是说，我们在 .cpp 文件中编写、运行 .c 程序，编译器也不会报错；那么类比过来，我们也就不难猜到，上述程序中的 iostream 是头文件，cout 是输出函数，对我们来说，唯一感到不解和陌生就只有 using namespace std; 这条语句，要理解这条语句，我们需要学习C++的命名空间相关知识。

二、命名空间

1、什么是命名空间

我们知道，在C语言中，如果我们的程序中包含某一头文件，那么我们就不能定义与其同名的全局变量，否则编译器就会报错；比如，在下面的程序中，我们包含了 <string.h> 头文件，该头文件中含有 trelen 函数，如果再用 strlen 作为变量名定义变量，就会造成重定义：

#include <stdio.h>
#include <string.h>

size_t strlen = 10;

int main()
{
	printf("%d\n", strlen);
}

但是C语言头文件中的库函数是非常多的，我们在编写大型项目的时候就难免可能会定义与库函数同名的变量，从而造成命名冲突；为了解决这个问题，C++引入了命名空间的概念。

命名空间：在C/C++中，变量、函数和后面要学到的类都是大量存在的，这些变量、函数和类的名称将都存 在于全局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化， 以避免命名冲突或名字污染，其中定义命名空间的关键字是 namespace。

2、命名空间的定义

定义命名空间很简单，只需要使用 namespace 关键字，后面跟上命名空间的名字，然后后接一对 {} 即可，{} 中即为命名空间的成员。

命名空间有如下特点：

• 命名空间的名称是随意取的；
• 命名空间中可以定义函数/变量/类型；
• 命名空间可以嵌套；
• 同一个工程中允许存在多个相同名称的命名空间，编译器最后会将其合成到同一个命名空间中；

命名空间中定义函数/变量/类型：

namespace N1
{
	//定义变量
	int strlen = 10;

	//定义类型
	typedef struct SLNode
	{
		int data;
		struct SLNode* next;
	}SLNode;

	//定义函数
	void Swap(int* p1, int* p2)
	{
		int tmp = *p1;
		*p1 = *p2;
		*p2 = tmp;
	}
}

命名空间嵌套定义：

namespace N1
{
	int strlen = 10;

	//嵌套定义
	namespace N2
	{
		typedef struct SLNode
		{
			int data;
			struct SLNode* next;
		}SLNode;
	}

	//嵌套多层
	namespace N3
	{
		void Swap(int* p1, int* p2)
		{
			int tmp = *p1;
			*p1 = *p2;
			*p2 = tmp;
		}
	}
}

同一个工程中允许存在多个名字相同的命名空间，编译器最后会将其合成到同一个命名空间中：

3、命名空间的使用

命名空间的使用有三种方式：命名空间名称加作用域限定符、使用 using 将命名空间中某个成员引入、使用 using namespace 将命名空间名称引入，其中的作用域限定符为：“::”；我们以下面这个命名空间为例：

namespace N
{
	int a = 0;
	int b = 1;

	int Add(int left, int right)
	{
		return left + right;
	}

	struct Node
	{
		struct Node* next;
		int val;
	};
}

命名空间名称加作用域限定符：

#include <iostream>
using namespace std;
int main()
{
	cout << N::a << endl;
	cout << N::Add(2, 3) << endl;
	return 0;
}

使用 using 将命名空间中某个成员引入：

#include <iostream>
using namespace std;
using N::a;
using N::Add;
int main()
{
	cout << a << endl;
	cout << Add(2, 3) << endl;
	return 0;
}

使用 using namespace 将命名空间名称引入：

#include <iostream>
using namespace std;
using namespace N;
int main()
{
	cout << a << endl;
	cout << Add(2, 3) << endl;
	return 0;
}

总的来说，我们想要使用命名空间中的变量，一共有两种方法：一种是使用作用域限定符 ::，另一种是引入命名空间，而引入命名空间又分为部分引入和全部引入。

嵌套定义的命名空间的使用：对于嵌套定义的命名空间，我们逐层使用作用域限定符即可，当然也可以通过逐层引入命名空间的方式使用：

4、注意事项

使用命名空间有几个需要理解和注意的地方：

1、一个命名空间就定义了一个新的作用域，这个域叫做命名空间域，命名空间中的所有内容都局限于该命名空间中；

2、命名空间中定义的变量都是全局变量：如下图，命名空间N中的成员变量a可以在函数test被访问，说明a的作用域是全局，所以a是全局变量；

3、编译器查找变量的规则是：默认现在局部域中查找，如果找不到，再到全局域中去找，如果在全局域中也没找到该变量，就报错；而命名空间的作用是改变编译器查找变量的规则，让编译器先到局部域中查找，如果找不到，就直接到命名空间中去找，再找不到就报错。

三、C++的输入输出

C++的输入输出语句如下：

#include<iostream>
// std是C++标准库的命名空间名，C++将标准库的定义实现都放到这个命名空间中
using namespace std; 
int main()
{
	int a = 0;
	cin >> a;  //console in
	cout << a << endl;  //console out endline
	return 0;
}

说明：

1、使用 cout 标准输出对象(控制台)和 cin 标准输入对象(键盘)时，必须包含 <iostream> 头文件 以及按命名空间使用方法使用 std。

2、 cout 和 cin 是全局的流对象，endl 是特殊的C++符号，表示换行输出，他们都包含在包含 <iostream>头文件中。

3、<<是流插入运算符，>>是流提取运算符。

4、使用C++输入输出更方便，不需要像 printf/scanf 输入输出时那样，需要手动控制格式；C++的输入输出可以自动识别变量类型。

5、实际上 cout 和 cin 分别是 ostream 和 istream 类型的对象，>>和<<也涉及运算符重载等知识， 这些知识我们我们后续才会学习，所以我们这里只是简单学习他们的使用。

注意：早期标准库将所有功能在全局域中实现，声明在.h后缀的头文件中，使用时只需包含对应头文件即可，后来将其实现在std命名空间下，为了和C头文件区分，也为了正确使用命名空间， 规定C++头文件不带.h；旧编译器(vc 6.0)中还支持格式，后续编译器已不支持，因此推荐使用+std的方式。

std命名空间的使用惯例：std是C++标准库的命名空间，如何展开std使用更合理呢？

1、 在日常练习中，建议直接using namespace std即可，因为这样很方便。

2、using namespace std展开后，标准库就全部暴露出来了，如果我们定义跟库重名的类型/对 象/函数，就存在冲突问题；

3、该问题在日常练习中很少出现，但是项目开发中代码较多、规模大，就很容易出现；所以建议在项目开发中像 std::cout 这样使用时指定命名空间 + using std::cout 来展开常用的库对象/类型等方式。

四、缺省参数

1、缺省参数的概念

缺省参数是声明或定义函数时为函数的参数指定一个缺省值；在调用该函数时，如果没有指定实 参则采用该形参的缺省值，否则使用指定的实参。

2、缺省参数的分类

缺省参数一共分为两类：全缺省参数和半缺省参数；

全缺省参数：

void Func(int a = 10, int b = 20, int c = 30)
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
}

半缺省参数：

void Func(int a, int b = 10, int c = 20)
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
}

注意事项

• 半缺省参数必须从右往左依次来给出，不能间隔着给；
• 缺省参数不能在函数声明和定义中同时出现，如果既存在函数声明，又存在函数定义，那么缺省参数只能在函数声明处给定；
• 缺省值必须是常量或者全局变量。

五、函数重载

1、函数重载的概念

函数重载是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数 或 类型 或 类型顺序)不同，常用来处理实现功能类似数据类型不同的问题。

#include<iostream>
using namespace std;

//参数类型不同构成函数重载
int Add(int left, int right)
{
	cout << "int Add(int left, int right)" << endl;
	return left + right;
}
double Add(double left, double right)
{
	cout << "double Add(double left, double right)" << endl;
	return left + right;
}

//参数个数不同构成函数重载
void f()
{
	cout << "f()" << endl;
}
void f(int a)

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

//参数类型顺序不同构成函数重载
void f(int a, char b)
{
	cout << "f(int a,char b)" << endl;
}
void f(char b, int a)
{
	cout << "f(char b, int a)" << endl;
}

int main()
{
	Add(10, 20);
	Add(10.1, 20.2);
	f();
	f(10);
	f(10, 'a');
	f('a', 10);
	return 0;
}

2、函数重载的原理 (重要)

我们在学习C语言 程序环境和预处理 的时候知道了一个程序要运行起来，需要经历预处理、编译、汇编、链接四个阶段；其中编译阶段会进行符号汇总，汇编阶段会生成符号表，而链接阶段则会对符号表进行合并与重定位，其中符号表会将每一个变量都关联上一个地址，但这个地址是否有效需要在链接阶段进行符号表的合并与重定位是时才能检查出来。

而对于上述过程中生成符号表这一阶段，C编译器与C++编译器所进行的操作是不同的 – C语言编译器会直接用变函数名作为符号表中的符号，而不会对函数名进行修饰；而C++编译器则是会对函数名进行修饰，用修饰后的名称来构成符号表。

注：由于Windows下vs的修饰规则过于复杂，而Linux下g++的修饰规则简单易懂，下面我们使 用了g++演示了这个修饰后的名字。

采用C语言编译器编译后结果：

采用C++编译器编译后结果：

经过对比后我们发现：在linux下，采用gcc (C语言编译器) 编译完成后，函数名字的修饰没有发生改变；而采用g++ (C++编译器) 编译完成后，函数名字的修饰发生改变，函数名由 前缀_Z+函数长度 +函数名+类型首字母 组成，即编译器将函数参数类型信息添加到了修改后的名字中。

通过上面这个实例就理解了：C语言没办法支持重载是因为同名函数没办法区分；而C++是通过函数修饰规则来区分，只要参数类型不同，修饰出来的名字就不一样，所以就支持重载。

同样，我们也理解了函数的返回值不同以及同类型参数的顺序不同是不构成重载的，因为C++编译器没办法区分；但其实即使是C++编译器把函数的返回值类型也加入了函数修饰规则，也仅仅是让它在语法层面是构成了重载而已，在实际使用中也是不构成重载的，因为函数传参时并不会传递函数的返回值类型，那么对于返回值不同，其他各方面都相同的函数而言，操作系统就不知道应该将参数传递给哪个函数，即在传递参数时出现了二义性，这时候编译也是会报错的。

注：对C/C++函数调用约定和名字修饰规则感兴趣的同学可以拓展学习一下下面这篇文章，里面有对vs下函数名修饰规则的讲解：C/C++ 函数调用约定 。

六、内联函数 (重要)

1、内联函数的概念

在 函数栈帧的创建和销毁 一节中我们知道：一个函数在开始调用时会建立函数栈帧，结束调用时会销毁函数栈帧，而函数栈帧的建立与销毁是有空间和时间上的开销的；

那么，对于功能简单、调用次数非常多的函数来说，每次调用都重新开辟栈帧势必就会造成效率的降低；比如 hoare 法的快速排序中，我们仅仅是每次单趟排序都会调用很多次 Swap 函数，更别说单趟排序也会被递归调用很多次，而 Swap 函数本身的功能恰好十分简单，那么该如何来对其进行优化呢？

在C语言中，我们使用宏函数来解决这个问题：我们直接将 Swap 函数写成宏函数，这样使得程序在预处理阶段直接将 Swap 函数替换成相应的代码，从而不再建立函数栈帧。

//源代码
#include <stdio.h>
#define Add(x,y) ((x)+(y))  //宏函数
int main()
{
	int ret = Add(2, 3);
	printf("%d\n", ret);
}

//经过预处理之后的代码
{
    //...此处是 stdio.h 展开的内容
}
int main()
{
    int ret = ((2)+(3));
    printf("%d\n", ret);
}

但是宏有如下主要缺点：

• 宏不能调试；
• 宏没有类型安全检查；
• 宏非常容易写错；

至于为什么宏有这些缺点以及这些缺点的具体体现场景，我在 程序环境和预处理 中已经有过介绍，这里就不再赘述。

基于C语言宏函数的这些缺陷，C++设计了内联函数：

以 inline 关键字修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开 (用函数体替换函数的调用)，没有函数调用建立栈帧的开销，内联函数可以提升程序运行的效率；

内联函数的编写和正常函数一样，仅仅是在函数的返回值类型前添加一个 inline 关键字 (这样就解决了C语言宏函数容易写错以及没有类型安全检查的缺陷)；

同时，在 debug 模式下，内联函数不会自动展开，需要我们对编译器进行相关设置；在 release 模式下，内联函数会自动展开 (这样解决了C语言宏函数无法调试的缺陷)；

所以说：内联函数在继承了C语言宏函数优点的同时几乎避免了其所有的缺陷。

2、内联函数定义及查看

内联函数的定义

//普通函数
int Add(int x, int y)
{
	return x + y;
}

//内联函数--添加inline关键字
inline int Add(int x, int y)
{
	return x + y;
}

内联函数的查看

1、 在 release 模式下，编译器会自动将内联函数展开，但由于 release 模式无法调试，所以我们这里无法观察；

2、 在 debug 模式下，需要在 项目->属性 中对编译器进行如下设置，否则不会展开 (因为 debug 模式下，编译器默认不会对代码进行优化，以下给出 VS2019 的设置方式)

在完成上述设置后我们 F10 进入调试，然后单击右键转到反汇编查看汇编代码：

普通函数的汇编代码

内联函数的汇编代码

注：大家在测试完成之后记得把编译器设置还原。

3、内联函数的特性

特性1

inline 对于编译器而言只是一个建议 (类似于C语言的 register 关键字)，不同编译器关于 inline 的实现机制可能不同，一般建议将具有如下特点的函数采用 inline 修饰：

• 函数规模较小 (即函数不是很长，具体没有准确的说法，取决于编译器内部实现)；
• 不是递归；
• 频繁调用；

下图为 《C++prime》第五版对于 inline 的建议：

我们可以简单写一个函数来验证内联函数的这个特性：

//把Add的内部逻辑复杂化
inline int Add(int x, int y)
{
	int sum = x + y;
	sum += x + y;
	sum = x + y;
	sum /= x + y;
	sum = x + y;
	sum = x + y;
	sum *= x + y;
	sum = x + y;
	sum = x + y;
	sum -= x + y;
	sum = x + y;
	sum += x + y;
	return sum;
}

Add 函数的汇编代码：

我们可以看到，当我们将 Add 函数的内部逻辑复杂化之后，尽管我们使用了 inline 关键字修饰 Add 函数，但是 Add 函数并没有被展开，而是和正常函数一样调用、建立栈帧。

特性2

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

需要注意的是，这里的空间指并不是指程序运行时占用的内存空间，而是指经过编译链接后得到的可执行程序 (.exe/.o文件) 所占用的空间；对于可执行程序变大的原因，我们以下面这个例子为例：

假设一个Func函数的汇编指令有50条，且这个函数要被重复调用1W次；

那么对于普通Func函数来说：我们每次调用Func都要转换出一条 call 汇编代码，调用1W次就有1W条汇编指令；但是Func函数本身只会在函数定义处被转换为汇编代码；所以普通Func函数经过编译之后的汇编指令一共有 1W+50 条；

而对于 inline 函数来说，由于 inline 函数会在所有调用的地方展开，也就是说，每调用一次Func函数，就会转换成50条对应的汇编代码；所以 inline Func函数经过编译之后的汇编指令一共有 50W 条；

而汇编指令的增多可能会导致我们编写的静态库/动态库增大，也有可能导致编写的 .exe 增大；这其实就是所谓的 “代码膨胀”，这也在一定程度上解释了为什么当内联函数过长时编译器不进行展开。

特性3

inline 不建议声明和定义分离，分离会导致链接错误，具体原因如下：

在 程序环境和预处理 中我们知道：程序在编译阶段进行符号汇总，汇编阶段生成符号表，链接阶段进行符号表的合并和重定位；

对于定义在本文件内的函数来说，编译器在汇编阶段会直接调用该函数，在调用过程中会生成对应的符号表，且此符号表中的地址一定是有效的，所以程序不会进行后续的链接操作；

而对于定义在其他文件中的函数，编译器会先在本文件内寻找该函数的声明，且声明生成的符号表中的地址是无效的；此时编译器会继续后续的链接操作；

链接过程中符号表的合并会将汇编阶段生成的所有符号表合并到一起，合并的意思是如果两个符号表中的函数名相同，那么编译器会选取与有效地址相关联的符号表，丢弃掉另一个与无效地址关联的；这样同时具有声明和定义的函数经过链接就只有一个符号表了；

而如果一个函数只有声明，而没有定义的话，那么它经过符号表的合并之后关联的仍然是一个无效地址，则在进行符号表的重定位时就会发生链接性错误；如果符号表中关联的是一个有效地址，重定位时编译器就会根据这个地址来调用函数，这样就可以实现跨文件调用函数；

对于 inline 函数来说，如果我们将函数的定义和声明分离，那么函数的声明在汇编阶段会生成一个符号表，里面关联的是一个无效的地址；但是由于 inline 函数是直接展开的，所以函数定义部分在汇编阶段并不会生成符号表；这时候就出现了上面的问题，程序经过符号表的合并之后 inline 函数仍然关联一个无效地址，会在重定位的时候发生链接性错误。如下：

图中，我们将 inline 函数的定义放在 Add.h 中，将其实现放在 Add.cpp 中，然后在 test.cpp 中包含 Add.h，这样经过预处理之后，test.cpp 中就包含了 inline 函数的声明；那么经过汇编，Add.cpp 中的 Add 函数由于是内联函数，会直接展开，所以不会生成符号表；

而在 test.cpp 中，经过汇编，Add 函数的声明会生成一个符号表，且符号表中的地址是无效的；而在链接阶段，Add 声明对应的符号表又不能匹配到有效的地址 (因为 test.cpp 中并没有生成 Add 函数的符号表)，所以重定位时发生链接型错误 (LNK 错误)；

正确的使用方法如下：如果有 .h 文件，将 inline 函数的定义直接放在 .h 文件中；如果没有 .h 文件，就直接放在本文件内部；

注：我们在C语言中学习的 函数栈帧的创建和销毁 和 程序环境和预处理 这两节内容虽然很难，但是对于理解C/C++的底层逻辑非常重要，希望大家能多花一点时间来理解它们。

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

1、类型名思考

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

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

例如下面 m 和 it 变量的类型：

#include <string>
#include <map>
int main()
{
	std::map<std::string, std::string> m{ { "apple", "苹果" }, { "orange","橙子" },{"pear","梨"} };
	std::map<std::string, std::string>::iterator it = m.begin();
	while (it != m.end())
	{
		//....
	}
	return 0;
}

std::map::iterator 是一个类型，但是该类型太长了，特别容易写错；可能聪明的同学可能已经想到：我们可以通过 typedef 给类型取别名，比如：

#include <string>
#include <map>
typedef std::map<std::string, std::string> Map;
int main()
{
	Map m{ { "apple", "苹果" },{ "orange", "橙子" }, {"pear","梨"} };
	{
		//....
	}
	return 0;
}

使用typedef给类型取别名确实可以简化代码，但是 typedef 有时会遇到新的难题：

2、auto 的概念

在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量，但遗憾的是一直没有人去使用它；因为当函数调用结束后，函数的栈帧会被销毁，那么存在于函数栈帧中的局部变量自然也会被销毁，这就使得 auto 修饰失去了意义；

而在C++11中，标准委员会赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。

int TestAuto()
{
	return 10;
}

int main()
{
	int a = 10;
	auto b = a;
	auto c = 'a';
	auto d = TestAuto();
	//auto e;  //无法通过编译，使用auto定义变量时必须对其进行初始化
	cout << typeid(b).name() << endl;
	cout << typeid(c).name() << endl;
	cout << typeid(d).name() << endl;
	return 0;
}

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

3、auto 的使用细则

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

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

在同一行定义多个变量

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

4、auto 不能推倒的场景

(1)、auto不能作为函数的参数，因为不是所有的参数都有初始化表达式，因此编译器可能无法推导出a的实际类型，所以直接规定auto不能作为函数形参：

(2)、 auto不能直接用来声明数组：数组需要根据元素类型及个数来开辟空间，而数组名代表指针，因此 auto 无法推导：

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

(4)、auto在实际中最常见的优势用法就是跟C++11提供的新式for循环，还有lambda表达式等进行配合使用。

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

1、范围 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循环后的括号被冒号分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。

void TestFor()
{
	int array[] = { 1,2,3,4,5 };

	//使用引用进行迭代--可以修改原数组
	for (auto& e : array)
		e *= 2;

	//使用局部变量进行迭代--不能修改原数组
	for (auto e : array)
		cout << e << " ";

	cout << endl;  //换行
}

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

2、范围 for 的使用条件

范围 for 的使用有如下条件限制：

(1)、for循环迭代的范围必须是确定的：对于数组而言，就是数组中第一个元素和最后一个元素的范围；对于类而言，应该提供 begin 和 end 的方法，begin 和 end 就是 for 循环迭代的范围；比如下面代码的范围就是不确定的：

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

(2)、 迭代的对象要实现++和==的操作；(关于迭代器我们以后会学习，现在大家了解一下就可以了)

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

在C语言中，通常我们在定义一个指针变量的时候会将其初始化为 NULL，避免后面对其错误使用造成野指针越界访问问题；其实这里的 NULL 是C语言中定义的一个宏，在传统的C头文件(stddef.h)中，可以看到如下代码：

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

我们可以看到，对于C语言来说，NULL 其实是数字0被强转为指针类型，相当于0处的地址；而对于C++来说，NULL 则被直接解释为数字0；虽然 0 和 (void*)0 二者在数值上相同，但是他们的类型是不相同的，一个是整形，另一个是指针；这就导致使用时会出现一些问题，比如下面这个例子：

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(NULL) 调用指针版本的 f(int*) 函数，但是由于NULL被定义成0，因此与程序的初衷相悖；

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

为了解决这个问题，C++11中专门为空指针设计了一个关键字 – nullptr，用来弥补C++98中空指针NULL存在的缺陷。(可以认为，nullptr 就是 (void*)0 )

nullptr 注意事项

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

型是不相同的，一个是整形，另一个是指针；这就导致使用时会出现一些问题，比如下面这个例子：

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(NULL) 调用指针版本的 f(int*) 函数，但是由于NULL被定义成0，因此与程序的初衷相悖；

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

为了解决这个问题，C++11中专门为空指针设计了一个关键字 – nullptr，用来弥补C++98中空指针NULL存在的缺陷。(可以认为，nullptr 就是 (void*)0 )

nullptr 注意事项

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