【C++】C++入门

会唱歌的小黄李

已于 2024-06-24 15:17:33 修改

阅读量1.1k

点赞数 28

分类专栏： C++ 文章标签： c++

于 2024-06-14 21:30:18 首次发布

本文链接：https://blog.csdn.net/qq_74897518/article/details/138543953

版权

C++ 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

前言

C++与C语言完全兼容，C语言的绝大部分内容可以直接用于C++的程序设计，用C语言编写的程序可以不加修改地用于C++，但是有很多问题C的语法解决不了或者解决不够好，C++新增了一些语法，容纳进去了面向对象编程思想，并增加了许多有用的库以及编程范式等，用起来会更方便。

C++是什么

C++（c plus plus）是一种计算机高级程序设计语言，由C语言扩展升级而产生，最早于1979年由本贾尼·斯特劳斯特卢普在AT&T贝尔工作室研发。
C++既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行以继承和多态为特点的面向对象的程序设计。C++擅长面向对象程序设计的同时，还可以进行基于过程的程序设计。
C++几乎可以创建任何类型的程序：游戏、设备驱动程序、HPC、云、桌面、嵌入式和移动应用等。甚至用于其他编程语言的库和编译器也使用C++编写
C++拥有计算机运行的实用性特征，同时还致力于提高大规模程序的编程质量与程序设计语言的问题描述能力。

C++历史版本

c++最重要的两个版本c++98、c++11
在这里插入图片描述

C++关键字

C++总计63个关键字，C语言32个关键字。我们会慢慢用到这些关键字的，不用去死记硬背，要灵活运用。学习任何一门编程语言都是一个循序渐进的过程。
在这里插入图片描述

命名空间

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

命名空间的定义

定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接一对{}即可，{}
中即为命名空间的成员。
一、命名空间普通定义

// 1. 正常的命名空间定义
namespace boke// boke是命名空间的名字
{
	 // 命名空间中可以定义变量/函数/类型
	 int rand = 10;
	 int Add(int left, int right)
	 {
	 return left + right;
	 }
	 struct Node
	 {
	 struct Node* next;
	 int val;
	 };
}

二、命名空间可以嵌套定义

//2. 命名空间可以嵌套
namespace N1
{
	int a;
	int b;
	int Add(int left, int right)
	 {
	     return left + right;
	 }
	namespace N2
	 {
	     int c;
	     int d;
	     int Sub(int left, int right)
	     {
	         return left - right;
	     }
	 }
}

三、同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。

所以相同名称的命名空间中不能出现同名的变量/函数/类型，否则会引起冲突。
注意：一个命名空间代表定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中。

命名空间的使用

一、加命名空间名称及作用域限定符
符号“::”在C++中叫做作用域限定符，我们通过“命名空间名称::命名空间成员”便可以访问到命名空间中相应的成员。
优点：不存在命名污染
缺点：用起来麻烦，每个都需要去指定命名空间

//加命名空间名称及作用域限定符
#include <stdio.h>
namespace N
{
	int a;
	double b;
}
int main()
{
	N::a = 10;//将命名空间中的成员a赋值为10
	printf("%d\n", N::a);//打印命名空间中的成员a
	return 0;
}

二、使用using将命名空间中某个成员引入
我们还可以通过“using 命名空间名称::命名空间成员”的方式将命名空间中指定的成员引入。这样一来，在该语句之后的代码中就可以直接使用引入的成员变量了。
不会造成大面积的命名污染，又可以把常用的给展开，这是一个折中的解决方案。

//使用using将命名空间中的成员引入
#include <stdio.h>
namespace N
{
	int a;
	double b;
}
using N::a;//将命名空间中的成员a引入
int main()
{
	a = 10;//将命名空间中的成员a赋值为10
	printf("%d\n", a);//打印命名空间中的成员a
	return 0;
}

三、使用using namespace 命名空间名称引入
最后一种方式就是通过”using namespace 命名空间名称“将命名空间中的全部成员引入。这样一来，在该语句之后的代码中就可以直接使用该命名空间内的全部成员了。
优点：用起来方便
缺点：把自己的定义暴露出去了，容易导致命名污染

//使用using namespace 命名空间名称引入
#include <stdio.h>
namespace N
{
	int a;
	double b;
}
using namespace N;//将命名空间N的所有成员引入
int main()
{
	a = 10;//将命名空间中的成员a赋值为10
	printf("%d\n", a);//打印命名空间中的成员a
	return 0;
}

注意：C++把标准库里面的东西都放到命名空间 std 中，所以在实际开发中，为了避免你自己写的变量/函数/类型等等与标准库中的冲突，建议不要把命名空间 std 直接展开到全局，而是把常用的展开就行。

C++输入&输出

C语言有自己的输入输出函数 scanf 和 printf，那么C++也有自己独特的输入输出方式，cin 标准输入流和 cout 标准输出流，必须包含头文件iostream和std标准库命名空间。

#include <iostream>
using namespace std;
int main()
{
	cout << "hello world!" << endl;
	return 0;
}

注意：早期标准库将所有功能在全局域中实现，声明在.h后缀的头文件中，使用时只需包含对应
头文件即可，后来将其实现在std命名空间下，为了和C头文件区分，也为了正确使用命名空间，
规定C++头文件不带.h；旧编译器(vc 6.0)中还支持<iostream.h>格式，后续编译器已不支持，因
此推荐使用+std的方式。
使用C++输入输出更方便，它可以自动识别变量的类型，不需增加数据格式控制，比如：整形–%d，字符–%c。我们如果要控制浮点数输出精度，控制整形输出进制格式等等。因为C++兼容C语言的用法，且c语言的用法比c++可能用起来更舒服，所以我们可以用printf控制。

#include <iostream>
using namespace std;
int main()
{
	int i;
	double d;
	char arr[20];
	cin >> i;//读取一个整型
	cin >> d;//读取一个浮点型
	cin >> arr;//读取一个字符串
	cout << i << endl;//打印整型i
	cout << d << endl;//打印浮点型d
	cout << arr << endl;//打印字符串arr
	//endl就相当与c语言中的\n,换行符。
	return 0;
}

缺省参数

缺省参数概念

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

void Func(int a = 0)
{
  	cout<<a<<endl;
}
int main()
{
	 Func();     // 没有传参时，使用参数的默认值0
	 Func(10);   // 传参时，使用指定的实参10
   return 0;
}

缺省参数分类

全缺省函数

函数的全部形参都给了指定的缺省值

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;
 }

以下要注意的四个点：
一、缺省参数不能在函数声明和定义中同时出现
若是在声明和定义中同时给出函数的缺省参数，如果我所给出的值是相同的，此时就会出现【重定义默认参数】的问题。若是两边给出的值不同的话，编译器在编译的时候就会产生歧义，不知道使用那一块的参数。
当然声明和定义你给哪边都可以都没有错，但是一般我们会选择给在声明处，因为声明处的头文件其他.cpp文件可以包含也便于在头文件里查找修改。若是将这些缺省参数放在放在了定义出，其他文件就没办法使用到了。

//错误示例
//test.h
void Print(int a=10, int b=20, int c = 30);
//test.c
void Print(int a=10, int b=20, int c = 30)
{
	cout << a << endl;
	cout << b << endl;
	cout << c << endl;
}

二、半缺省参数必须从右往左依次来给出，不能间隔着给

//错误示例，以下这两种都是错的
void TestFunc(int a=12, int b = 10, int c )
{
    cout<<"a = "<<a<<endl;
    cout<<"b = "<<b<<endl;
    cout<<"c = "<<c<<endl;
}
void TestFunc(int a=12, int b , int c=10 )
{
    cout<<"a = "<<a<<endl;
    cout<<"b = "<<b<<endl;
    cout<<"c = "<<c<<endl;
}

三、缺省值必须是常量或者全局变量
这一点很好理解，你给出的缺省值必须是一个固定的值，而不是一个可修改的变量，否则这个缺省值将毫无意义；对于缺省值一般我们不会使用全局变量，因为全局变量会存在线程安全的问题，日常写代码也是不推荐使用全局变量。
四、C语言不支持（编译器不支持）

函数重载

函数重载概念

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

#include<iostream>
using namespace std;
// 1、参数类型不同
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;
}


// 2、参数个数不同
void f()
{
 cout << "f()" << endl;
}
void f(int a)
{
 cout << "f(int a)" << endl;
}


// 3、参数类型顺序不同
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;
}

函数重载的原理(名字修饰)

为什么C++支持函数重载，而C语言不支持函数重载呢？

我们知道，一个C/C++程序要运行起来都需要经历以下几个阶段：预处理、编译、汇编、链接。

我们知道，在编译阶段会将程序中的每个源文件的全局范围的变量符号分别进行汇总。在汇编阶段会给每个源文件汇总出来的符号分配一个地址（若符号只是一个声明，则给其分配一个无意义的地址），然后分别生成一个符号表。最后在链接期间会将每个源文件的符号表进行合并，若不同源文件的符号表中出现了相同的符号，则取合法的地址为合并后的地址（重定位）。

在C语言中，汇编阶段进行符号汇总时，一个函数汇总后的符号就是其函数名，所以当汇总时发现多个相同的函数符号时，编译器便会报错。而C++在进行符号汇总时，对函数的名字修饰做了改动，函数汇总出的符号不再单单是函数的函数名，而是通过其参数的类型和个数以及顺序等信息汇总出一个符号，这样一来，就算是函数名相同的函数，只要其参数的类型或参数的个数或参数的顺序不同，那么汇总出来的符号也就不同了。

注：不同编译器下，对函数名的修饰不同，但都是一样的。

总结：
1、C语言不能支持重载，是因为同名函数没办法区分。而C++是通过函数修饰规则来区分的，只要函数的形参列表不同，修饰出来的名字就不一样，也就支持了重载。
2、另外我们也理解了，为什么函数重载要求参数不同，根返回值没关系。

extern “C”
如果想要给C用，需要将C++库中的部分函数按照C的风格来编译，在函数前加 extern “C”，意思是告诉编译器，将该函数按照C的修饰规则来编译。

extern "C" void Add(int a, int b);

总结：在函数前加“extern C”后，该函数便不能支持重载了。
C++项目可以调用C++的库，也可以调用C的库。
C的项目可以调用C的库，如果要调用C++的库，需要在该函数前加上 extern “C”

引用

引用概念

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空
间，它和它引用的变量共用同一块内存空间。
基本形式：类型& 引用变量名(对象名) = 引用实体；
注意：引用类型必须和引用实体是同种类型的

void TestRef()
{
    int a = 10;
    int& ra = a;//<====定义引用类型
    printf("%p\n", &a);
    printf("%p\n", &ra);
}

引用的特性

引用在定义时必须初始化

int a=10
int& b=a;

一个变量可以有多个引用

int a=10;
int& b-a;
int& c=a;
int& d=a;

引用一旦引用一个实体，再不能引用其他实体

int main()
{	
	int a = 10;
	int& b = a;

	int c = 20;
	b = c;  //error
    
    return 0;
}

const常引用

const 修饰的原理：缩小了原有的「读写权限」，由「可读可写」变成了「只能读不能写」，
不变或者缩小你的读写权限是可以的，但是放大你的读写权限是不行的。

//示例
const int a = 10;
//int& ra = a;     //错误：ra变成a的别名，能读能写，放大了读写权限
const int& ra = a; //正确

//示例
int b = 20;
const int& rb = b;  //正确：rb变成b的别名，只能读不能写，缩小了读写权限
//rb = 30;          //错误，不能写
b = 30;             //正确

int i = 10;
//double& r = i;     //错误
const double& r = i; //正确

这是为什么加个 const 就可以了呢？
引用时如存在隐式类型转换，也需在类型前加const，且这时引用的不是变量本身，而是隐式类型转换时的临时空间。(临时空间得属性是const)
在这里插入图片描述
隐式类型转换也会产生临时变量，所以程序运行结果是：不相同

int main()
{
	char ch = 0xff;
	int j = 0xff;
	if (ch == j)  //ch被整型提升成int类型，生成一个int类型的临时变量与 j 比较
	{
		cout << "相同" << endl;
	}
	else
	{
		cout << "不相同" << endl;
	}

	return 0;
}

使用场景

一、做参数
1、形参变量的改变，要影响到实参，用指针或引用解决

//交换两数的值（指针做参数）
void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

//交换两数的值（引用做参数）
void Swap(int& ra, int& rb)
{
	int tmp = ra;
	ra = rb;
	rb = tmp;
}

2、引用在顺序栈中应用，如果为了减少传参时的拷贝，提高效率，以及保护形参不会被改变，用const 常引用

typedef struct Stack
{
	int* a;
	int top;
	int capacity;
}Stack;

//这里的引用是为了通过改变形参来影响实参
void StackInit(Stack& s)
{
	//...栈的初始化会改变指针的指向
}

//这里的常引用是为了减少传参时的拷贝，提高效率，以及保护形参不会被改变
void StackPrint(const Stack& s)
{
	//...
}

3、const常引用做参数的第二个好处，既可以接收变量，也可以接收常量

void func(const int& n)
{
	//...
}
int main()
{
	int i = 10;
	func(i);  //（1）传变量
    func(20); //（2）传常量
	const int j = 30;
	func(j);  //（3）传常变量
	return 0;
}

总结：
1、引用做参数，通过改变形参来影响实参
2、引用做参数，减少传参时的拷贝，提高效率（尤其是当参数变量比较大时）
3、如果函数中不改变形参的话，建议用 const 常引用做参数，因为可以保护形参避免被误改变
即可以传普通对象，还可以传 const 对象

二、做返回值

//传值返回
int Add(int a, int b)
{
	int c = a + b;
	return c;
}

int main()
{
	int ret = Add(1, 2);
	cout << "Add(1, 2) is :" << ret << endl;
	return 0;
}

在这里插入图片描述
原理分析：传值返回会产生一个变量 c 的临时拷贝，作为返回值，并不是直接返回变量 c，因为变量 c 随着函数 Add 栈帧销毁已经还给操作系统了

//传引用返回
int& Add(int a, int b)
{
	int c = a + b;
	return c;
}

int main()
{
	int ret = Add(1, 2);
	cout << "Add(1, 2) is :" << ret << endl;
	return 0;
}

在这里插入图片描述
这里就没有产生临时变量了，Add函数返回了整型变量 c 的引用 int&，严格意义上来讲，这里 Add(1, 2) 的结果是不确定的，取决于平台销毁栈帧时是否会清理栈帧空间中的数据，如果清理了，则是随机值，如果没有清理，则是 3。（此段代码在VS2022上运行时结果是 3，说明VS上没有清理栈帧）

当函数返回，栈帧销毁（所以变量 c 所在的空间已被销毁），我们又通过 tmp 去访问已经被销毁的空间去赋值给 ret，本身就是一种越界行为，是错误的，访问到到的值也是不确定的，所以这里的传引用返回是错误用法，只是为了帮助大家理解下传值返回和传引用返回，编译器的特性是什么。

我们返回的数据不能是函数内部创建的普通局部变量，因为在函数内部定义的普通的局部变量会随着函数调用的结束而被销毁。我们返回的数据必须是被static修饰或者是动态开辟的或者是全局变量等不会随着函数调用的结束而被销毁的数据。
所以注意：如果函数返回时，出了函数作用域，返回对象还未还给系统，则可以使用引用返回；如果已经还给系统了，则必须使用传值返回。 在这里插入图片描述

引用和指针的区别

在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。
在这里插入图片描述

在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。
底层实现意思其实就是编译转换成汇编去实现这个语法。
在这里插入图片描述
引用和指针的区别（重要）：

引用概念上定义一个变量的别名，指针存储一个变量地址。
引用在定义时必须初始化，指针没有要求
引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何
一个同类型实体
没有NULL引用，但有NULL指针
在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32
位平台下占4个字节)
引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
有多级指针，但是没有多级引用
访问实体方式不同，指针需要显式解引用，引用编译器自己处理
引用比指针使用起来相对更安全

内联函数

内联函数概念

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

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

int main()
{
	int ret = Add(10, 20);

	return 0;
}

左边是没有加内联，右边是加了内联
在这里插入图片描述

内联函数的特性

inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用，缺陷：可能会使目标文件变大，优势：少了调用开销，提高程序运行效率（所以代码很长或者有循环/递归的函数不适宜使用作为内联函数。代码比较短，一般小于10行左右，频繁调用的适合inline，长的函数展开，会引发代码膨胀，编译出来的可执行程序变大）
inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不是递归、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。
inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。

auto关键字(C++11)

auto介绍

在早期的C/C++中auto的含义是：使用auto修饰的变量是具有自动存储器的局部变量，但遗憾的是一直没有人去使用它。
在C++11中，标准委员会赋予了auto全新的含义：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。

#include <iostream>
using namespace std;
double Fun()
{
	return 3.14;
}
int main()
{
	int a = 10;
	auto b = a;
	auto c = 'A';
	auto d = Fun();
	//打印变量b,c,d的类型
	cout << typeid(b).name() << endl;//打印结果为int
	cout << typeid(c).name() << endl;//打印结果为char
	cout << typeid(d).name() << endl;//打印结果为double
	return 0;
}

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

auto的使用细则

一、auto与指针和引用结合起来使用
用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时必须加&

#include <iostream>
using namespace std;
int main()
{
	int a = 10;
	auto b = &a;   //自动推导出b的类型为int*
	auto* c = &a;  //自动推导出c的类型为int*
	auto& d = a;   //自动推导出d的类型为int
	//打印变量b,c,d的类型
	cout << typeid(b).name() << endl;//打印结果为int*
	cout << typeid(c).name() << endl;//打印结果为int*
	cout << typeid(d).name() << endl;//打印结果为int
	return 0;
}

注意：用auto声明引用时必须加&，否则创建的只是与实体类型相同的普通变量。

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

int main()
{
	auto a = 1, b = 2; //正确
	auto c = 3, d = 4.0; //编译器报错：“auto”必须始终推导为同一类型
	return 0;
}

auto不能推导的场景

一、auto不能作为函数的参数
以下代码编译失败，auto不能作为形参类型，因为编译器无法对x的实际类型进行推导。

void TestAuto(auto x)
{}

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

int main()
{
	int a[] = { 1, 2, 3 };
	auto b[] = { 4, 5, 6 };//error
	return 0;
}

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

范围for的语法

若是在C++98中我们要遍历一个数组，可以按照以下方式：

	int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	//将数组元素值全部乘以2
	for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		arr[i] *= 2;
	}
	//打印数组中的所有元素
	for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;

以上方式也是我们C语言中所用的遍历数组的方式，但对于一个有范围的集合而言，循环是多余的，有时还容易犯错。因此C++11中引入了基于范围的for循环。for循环后的括号由冒号分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。

	int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	//将数组元素值全部乘以2
	for (auto& e : arr)
	{
		e *= 2;
	}
	//打印数组中的所有元素
	for (auto e : arr)
	{
		cout << e << " ";
	}
	cout << endl;

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

范围for的使用条件

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

二、迭代的对象要实现++和==操作
这是关于迭代器的问题，大家先了解一下。

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

C++98中的指针空值

在良好的C/C++编程习惯中，在声明一个变量的同时最好给该变量一个合适的初始值，否则可能会出现不可预料的错误。比如未初始化的指针，如果一个指针没有合法的指向，我们基本都是按如下方式对其进行初始化：

int* p1 = NULL;
int* p2 = 0;

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

/* Define NULL pointer value */
#ifndef NULL
#ifdef __cplusplus
#define NULL    0
#else  /* __cplusplus */
#define NULL    ((void *)0)
#endif  /* __cplusplus */
#endif  /* NULL */

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

#include <iostream>
using namespace std;
void Fun(int p)
{
	cout << "Fun(int)" << endl;
}
void Fun(int* p)
{
	cout << "Fun(int*)" << endl;
}
int main()
{
	Fun(0);           //打印结果为 Fun(int)
	Fun(NULL);        //打印结果为 Fun(int)
	Fun((int*)NULL);  //打印结果为 Fun(int*)
	return 0;
}

程序本意本意是想通过Fun(NULL)调用指针版本的Fun(int* p)函数，但是由于NULL被定义为0，Fun(NULL)最终调用的是Fun(int p)函数。

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

C++11中的指针空值

对于C++98中的问题，C++11引入了关键字nullptr。

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