?个人主页：库库的里昂
✨收录专栏：C++从练气到飞升
?鸟欲高飞先振翅，人求上进先读书。
目录
推荐
前言
什么是C++
C++的发展史
?命名空间
命名空间定义
命名空间使用
命名空间的嵌套
std命名空间的使用
?C++输入&输出
缺省参数的定义
缺省参数分类
缺省参数出现的位置
?函数重载
函数重载的概念
函数重载的种类
C++支持函数重载的原理
?引用
引用的概念
引用的特性
引用的使用场景
传值和引用性能比较
常引用
引用和指针的区别
?内联函数
内联函数的概念
内联函数的特征
?auto关键字
auto简介
auto使用规则
auto无法使用的场景
?基于范围的for循环
范围for的语法
范围for的使用条件
?指针空值nullptr
⛳️推荐
前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到网站
前言
什么是C++
C语言是结构化和模块化的语言，适合处理较小规模的程序。对于复杂的问题，规模较大的程序，需要高度的抽象和建模时，C语言则不合适。为了解决软件危机， 20世纪80年代， 计算机界提出了OOP(object oriented programming：面向对象)思想，支持面向对象的程序设计语言应运而生。
1982年，Bjarne Stroustrup博士在C语言的基础上引入并扩充了面向对象的概念，发明了一种新的程序语言。为了表达该语言与C语言的渊源关系，命名为C++。因此：C++是基于C语言而产生的，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行面向对象的程序设计。
C++的发展史
1979年，贝尔实验室的本贾尼等人试图分析unix内核的时候，试图将内核模块化，于是在C语言的基础上进行扩展，增加了类的机制，完成了一个可以运行的预处理程序，称之为C with classes。
语言的发展就像是练功打怪升级一样，也是逐步递进，由浅入深的过程。我们先来看下C++的历史版本。
C++还在不断的向后发展。但是：现在公司主流使用还是C++98和C++11，所有大家不用追求最新，重点将C++98和C++11掌握好，等工作后，随着对C++理解不断加深，有兴趣的小伙伴可以去琢磨下更新的特性。
?命名空间
在C/C++中，变量、函数和后面要学到的类都是大量存在的，这些变量、函数和类的名称将都存在于全局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题的。
#include <stdio.h>#include <stdlib.h>int rand = 10;// C语言没办法解决类似这样的命名冲突问题，所以C++提出了namespace来解决int main(){ printf("%d\n", rand); return 0;}// 编译后后报错：error C2365: “rand”: 重定义；以前的定义是“函数”命名空间定义
命名空间的定义由两部分构成：首先是关键字namespace，后面跟命名空间的名字，然后接一对{}，{}中即为命名空间的成员。 命名空间中可以定义变量、函数、类型和其他命名空间。
namespace N1//命名空间的名字{ //定义变量 int rand = 10; //定义函数 int Add(int left, int right) { return left + right; } //定义类型 struct Node { struct Node* next; int val; }; //嵌套命名空间 namespace N2 { int Sub(int left, int right) { return left - right; } }}注意：
一个命名空间就定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中。用一个工程中允许出现多个相同名称的命名空间，编译器最后会将它们合并为一个命名空间。命名空间使用
命名空间的使用有三种方式：
加命名空间名称及域作用限定符namespace N{ int a=10; int b=5;} int main(){ printf("%d\n", N::a); return 0; }using N::b;int main(){ printf("%d\n", N::a); printf("%d\n", b); return 0; }namespace N{ int a=10; int b=5;} int a=20; using namespce N; int main(){ printf("%d\n", a); //a不明确，有二义性 printf("%d\n", ::a); //访问全局的a printf("%d\n", N::a); //访问N中的a printf("%d\n", b); return 0; }N中的成员a 就与全局作用域中的a 产生了冲突。这种冲突是允许存在的，但是要想使用冲突的名字，我们就必须明确指出名字的版本。main函数中所有未加限定的a都会产生二义性错误。
这时我们必须使用域作用限定符(::)来明确指出所需的版本
: :a来表示全局作用域中的aN: :a来表示定义在N中的a注意：
如果命名空间没有展开，编译器默认是不会搜索命名空间中的变量，去访问变量是访问不到的。
访问的优先级：局部域 > 全局域
命名空间的嵌套
嵌套的命名空间同时是一个嵌套的作用域，它嵌套在外层命名空间的作用域中。嵌套的命名空间中的名字遵循的规则与往常类似：内层命名空间声明的名字将隐藏外层命名空间声明的同名成员。在嵌套的命名空间中定义的名字只在内层命名空间中有效，外层命名空间的代码想要访问它必须在名字前添加限定符。
namespace N{ int a = 10; namespace N1 { int a = 20; //将外层作用域的a隐藏了 int b = 15; namespace N2 { int c = N1::b; }} int main(){ printf("%d\n", N::N2::c); printf("%d\n", N::N1::a); printf("%d\n", N::a); return 0;}std命名空间的使用
std是C++标准库的命名空间，如何展开std使用更合理呢？
在日常练习中，建议直接using namespace std；即可，这样就很方便。 using namespace std；展开，标准库就全部暴露出来了，如果我们定义跟库重名的类型、对象、函数，就存在冲突问题。该问题在日常练习中很少出现，但是项目开发中代码较多、规模 大，就很容易出现。所以建议在项目开发中使用，像std::cout这样使用时指定命名空间例如： using std::cout展开常用的库对象、类型等方式。?C++输入&输出
#include <iostream>using namespace std; int main(){int a = 10;double b = 10.5;cout << a << endl;cout << b << endl;return 0;}我们在项目中要经常使用 cout 和 endl，每次指定命名空间很不方便，直接展开会全部暴露，有冲突风险，我们可以指定展开来解决问题。
using std::cout;using std::endl;说明：
使用cout标准输出对象(控制台)和cin标准输入对象(键盘)时，必须包含< iostream >头文件以及按命名空间使用方法使用std。cout 和 cin 是全局的流对象，endl 是特殊的C++符号，表示换行输出，他们都包含在包含 < iostream >头文件中。<<是流插入运算符，>>是流提取运算符。使用C++输入输出更方便，不需要像 printf和scanf 输入输出时那样，需要手动控制格式。 C++的输入输出可以自动识别变量类型。 ?缺省参数
缺省参数的定义
缺省参数是声明或定义函数时为函数的参数指定一个缺省值。在调用该函数时，如果没有指定实参则采用该形参的缺省值，否则使用指定的实参。
void Func(int a = 5){ cout << a << endl;} int main(){ Func(); // 没有传参时，使用参数的默认值 Func(10); // 传参时，使用指定的实参 return 0;}
上面代码在第一次调用 Func() 时，没有传递参数，a 就使用了缺省值。
缺省参数分类
全缺省参数 -- 所有参数都给了缺省值void Func(int a = 10, int b = 20, int c = 30){ cout<<"a = "<<a<<endl; cout<<"b = "<<b<<endl; cout<<"c = "<<c<<endl;} int main(){ Func(1，2，3); Func(1，2); Func(1); Func(); return 0;}
全缺省参数在传参时，参数是按照从左往右的顺序进行缺省的，不能跳着缺省，例如:Func(1, ,3) ，让第一个形参和第三个形参都使用传递值，而让第二个参数使用缺省值，这种做法是不被允许的。
半缺省参数 -- 部分的参数给了缺省值void Func(int a, int b = 20, int c = 30){ cout<<"a = "<<a<<endl; cout<<"b = "<<b<<endl; cout<<"c = "<<c<<endl;} int main(){ Func(1，2，3); Func(1，2); Func(1); return 0;}半缺省参数必须从右往左依次来给出，不能间隔着给。
注意：
缺省参数不能在函数声明和定义中同时出现，只能出现在函数声明中。缺省值必须是常量或者全局变量。缺省参数出现的位置
缺省参数只能出现在函数声明中，如下面的代码，在声明和定义中都给了缺省参数，而且给定的值不相同，就不知道以哪个值为准。
//a.hvoid Func(int a = 10); //a.cppvoid Func(int a = 20){}不能只在声明处给缺省参数，如下面的代码，如果只在声明处给缺省参数，在其他的文件中没有缺省参数，就不知是什么值。
//a.cppvoid Func(int a = 10){} //b.cppvoid Func(int a){}?函数重载
自然语言中，一个词可以有多重含义，人们可以通过上下文来判断该词真实的含义，即该词被重载了。 比如：以前有一个笑话，国有两个体育项目大家根本不用看，也不用担心。一个是乒乓球，一个 是男足。前者是“谁也赢不了！”，后者是“谁也赢不了！”
函数重载的概念
函数重载是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数或类型或类型顺序)不同，常用来处理实现功能类似数据类型不同的问题。
函数重载的种类
参数类型不同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;} int main(){ cout << Add(1, 2) << endl; cout << Add(1.0, 2.0) << endl;}上面的代码定义了两个同名的Add函数，但是它们的参数类型不同，第一个函数的两个参数都是int型，第二个函数的两个参数都是double型，在调用Add函数的时候，编译器会根据所传实参的类型自动判断调用哪个函数。
参数个数不同void Fun(){ cout << "f()" << endl;} void Fun(int a){ cout << "f(int a)" << endl;} int main(){ Fun(); Fun(1); return 0;}
void Text(int a, char b){ cout << "Text(int a,char b)" << endl;} void Text(char b, int a){ cout << "Text(char b, int a)" << endl;} int main(){ Text(1, 'a'); Text('a', 1); return 0;}void Fun(){ cout << "f()" << endl;} void Fun(int a = 10){ cout << "f(int a)" << endl;} int main(){ Fun(); //无参调用会出现歧义 Fun(1); //调用的是第二个 return 0;}上面代码中的两个Fun函数构成函数重载，编译可以通过，因为第一个没有参数，第二个有一个整型参数，属于上面的参数个数不同的情况。但是Fun函数存在一个问题：在没有参数调用的时候会产生歧义，因为有缺省参数，所以对两个Fun函数来说，都可以不传参。
注意：返回值的类型与函数是否构成重载无关。
C++支持函数重载的原理
在C/C++中，一个程序要运行起来，需要经历以下几个阶段：预处理、编译、汇编、链接。
我们想理解清楚函数重载，还要了解函数签名的概念，函数签名包含了一个函数的信息，包括函数名、它的参数类型、他所在的类和名称空间以及其他信息。函数签名用于识别不同的函数。 C++编译器和链接器都使用符号来标识和处理函数和变量，所以对于不同函数签名的函数，即使函数名相同，编译器和链接器都认为他们是不同的函数。
Linux环境下采用C语言编译器编译后结果
可以看出经过gcc编译后，函数名字的修饰没有发生改变。这也就是为什么C语言不支持函数重
载，因为同名函数没办法区分。
采用C++编译器编译后结果
其中_Z是固定的前缀；3表示函数名的长度；Add就是函数名；i是int的缩写，两个i表示两个参数都是int类型，d是double的缩写，两个d表示两个参数都是double类型。C++就是通过函数修饰规则来区分，只要参数不同，修饰出来的名字就不一样，就支持了重载。通过分析可以发现，修饰后的名称中并不包含任何于函数返回值有关的信息，因此也验证了上面说的返回值的类型与函数是否构成重载无关。
总结：
C语言之所以没办法支持重载，是因为同名函数没办法区分。而C++是通过函数修饰规则来区分，只要参数不同，修饰出来的名字就不一样，就支持了重载。如果两个函数函数名和参数是一样的，返回值不同是不构成重载的，因为调用时编译器没办法区分。?引用
引用的概念
引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空 间，它和它引用的变量共用同一块内存空间。
类型& 引用变量名(对象名) = 引用实体
int main(){ int a = 0; int& b = a;//定义引用类型，b是a的引用 return 0;}注意：引用类型必须和引用实体是同种类型的
引用的特性
引用在定义时必须初始化int main(){ int a = 10; int& b; //错误的 return 0;}
在使用引用时，我们必须对变量进行初始化。int& b = a;，这样的代码才是被允许的。
引用不能改变指向int main(){ int a = 10; int b = 20; int& c = a; c = b; return 0;}
我们可以看到b和c的地址不同，所以c = b表示的不是c是b引用，而是是把b变量的值赋值给c引用的实体，c依旧是a的引用，所以引用一旦引用一个实体，再不能引用其他实体，也就是引用不能改变指向。
引用的使用场景
?做参数
引用做参数的意义：
做输出型参数，即要求形参的改变可以影响实参提高效率，自定义类型传参，用引用可以避免拷贝构造，尤其是大对象和深拷贝对象交换两个整型变量：
void Swap(int& num1, int& num2){ int tmp = num1; num1 = num2; num2 = tmp;} int main(){ int a = 5; int b = 10; Swap(a,b); return 0;}如上代码，我们可以使用引用做参数实现了两个数的交换，num1是 a 的引用，和 a 在同一块空间，对num1的修改也就是对 a 修改， b 同理，所以在函数体内交换num1和num2实际上就是交换 a 和 b 。以前交换两个数的值，我们需要传递地址，还要进行解引用，相对繁琐。
交换两个指针变量：
void Swap(int*& p1, int*& p2){ int* tmp = p1; p1 = p2; p2 = tmp;} int main(){ int a = 5; int b = 10; int* pa = &a; int* pb = &b; Swap(pa,pb); return 0;}如果用C语言来实现交换两个指针变量，实参需要传递指针变量的地址，那形参就需要用二级指针来接收，这显然十分容易出错。有了引用之后，实参直接传递指针变量即可，形参用指针类型的引用。
?做返回值
引用做返回值的意义：
减少拷贝，提高效率。可以同时读取和修改返回对象int& add(int x, int y){ int sum = x + y; return sum;} int main(){ int a = 5; int b = 10; int ret = add(a, b); cout << ret << endl; return 0;}如上代码，我们使用传值返回，调用函数要创建栈帧，sum是add函数中的一个局部变量，存储在当前函数的栈帧中，函数调用结束栈帧销毁，sum也会随之销毁，对于这种传值返回，会生成一个临时的中间变量，用来存储返回值，在返回值比较小的情况下，这个临时的中间变量一般就是寄存器。
如上代码，传引用就是给sum起了一个别名，返回的值就是sum的别名，但是这里会出现问题，函数调用结束栈帧销毁，sum也会随之销毁，返回它的值再进行调用就是越界访问，打印出的值为随机值。
可是这里的值为什么是正确的呢？这是取决于编译器的，看编译器是否会对这块空间进行清理。
传值和引用性能比较
以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直 接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效 率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低。
struct A{ int a[100000];}; void TestFunc1(A a){ ;} void TestFunc2(A& a){ ;} void TestFunc3(A* a){ ;} //引用传参————可以提高效率（大对象或者深拷贝的类对象）void TestRefAndValue(){ A a; // 以值作为函数参数 size_t begin1 = clock(); for (size_t i = 0; i < 10000; ++i)//就是单纯的调用一万次这个函数传一万次参 TestFunc1(a); size_t end1 = clock(); // 以引用作为函数参数 size_t begin2 = clock(); for (size_t i = 0; i < 10000; ++i) TestFunc2(a);//这里直接传的是变量名 size_t end2 = clock(); //以指针作为函数参数 size_t begin3 = clock(); for (int i = 0; i < 10000; i++){ TestFunc3(&a);} size_t end3 = clock(); // 分别计算两个函数运行结束后的时间 cout << "TestFunc1(A)-time:" << end1 - begin1 << endl; cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl; cout << "TestFunc3(A*)-time:" << end3 - begin3 << endl;}
值和引用的作为返回值类型的性能比较：
struct A{ int a[100000];};A a;//全局的，函数栈帧销毁后还在 // 值返回A TestFunc1(){ return a;} // 引用返回A& TestFunc2(){ return a;}void TestReturnByRefOrValue(){ // 以值作为函数的返回值类型 size_t begin1 = clock(); for (size_t i = 0; i < 100000; ++i) TestFunc1();//就让他返回不接收 size_t end1 = clock(); // 以引用作为函数的返回值类型 size_t begin2 = clock(); for (size_t i = 0; i < 100000; ++i) TestFunc2(); size_t end2 = clock(); // 计算两个函数运算完成之后的时间 cout << "TestFunc1 time:" << end1 - begin1 << endl; cout << "TestFunc2 time:" << end2 - begin2 << endl;} int main(){ TestReturnByRefOrValue(); return 0;}
常引用
? 权限放大
int main(){ const int a = 10; int& b = a; return 0;}
上面代码中，用const定义了一个常变量 a ，然后给a取一个别名 b ，这段代码在编译过程中出现了错误，这是为什么呢？
a 是一个常变量，是不可以被修改的，给 a 取别名为变量 b ，变量b没有用const修饰，所以不具有常属性，是可以被修改的，相当于权限的放大，这种情况是不允许的。正确的做法是：
int main(){ const int a = 10; const int& b = a; return 0;}? 权限缩小
int main(){ int a = 10; const int& b = a; return 0;}上面代码中，给一个普通的变量a取了一个别名b，这个b是一个常引用。这意味着，可以通过a变量去对内存中存储的数据进行修改，但是不能通过b去修改内存中存储的数据，但是b会跟着变。
引用和指针的区别
引用在概念上定义一个变量的别名，指针存储一个变量的地址。引用在定义时必须初始化，指针没有要求。引用在初始化时引用一个一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体。没有NULL引用，但有NULL空指针。在sizeof中的含义不同，引用结果为引用类型的大小，但指针始终是地址空间所占字节个数（32位机下占四个字节，64位机下占八个字节）。引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小。有多级指针，但是没多级引用。访问实体方式不同。指针显式解引用，引用编译器自己做处理。引用比指针使用起来相对更安全。?内联函数
普通的函数在调用的时候会开辟函数栈帧，会产生一定量的消耗，在C语言中可以用宏函数来解决这个问题，但是宏存在以下缺陷：复杂、容易出错、可读性差、不能调试。为此，C++中引入了内联函数这种方法。.
内联函数的概念
以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数调 用建立栈帧的开销，内联函数提升程序运行的效率。
int Add(int x, int y){ return x + y ;} int main(){ int ret = 0; ret = Add(3, 5); cout << ret << endl; return 0;}
?内联函数
inline int Add(int x, int y){ return x + y ;}内联函数在编译期间编译器会用函数体替换函数的调用。
注意：在默认的Debug模式下，内联函数是不会展开的。
查看方式：
在release模式下，查看编译器生成的汇编代码中是否存在call Add。在debug模式下，需要对编译器进行设置，否则不会展开，需要进行设置，设置过程如下：
内联函数的特征
inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用，缺陷：可能会使目标文件变大，优势：少了调用开销，提高程序运行效率。 inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不是递归、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址 了，链接就会找不到。?auto关键字
随着程序越来越复杂，程序中用到的类型也越来越复杂，例如：
#include <vector>#include <string> int mian(){ vetcor<string> v; vetcor<string>::iterator it = v.begin(); return 0;}vetcor<string>::iterator是一个类型，但是该类型太长了，特别容易写错。在C语言中，我们可以通过 typedef 给类型取别名，比如：
typedef vetcor<string>::iterator Map；使用 typedef 给类型取别名确实可以简化代码，但使用 typedef 又会遇到新的问题。在编程时，常常需要把表达式的值赋值给变量，这就要求在声明变量的时候清楚地知道表达式的类型。但这点有时很难做到，因此C++11给auto赋予了新的含义。
auto it = v.degin();auto简介
在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量， 但在C++11中：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。简单来说，auto会根据表达式自动推导类型。
int main(){ int a = 0; auto b = a; auto& c = a; auto* d = &a; //typeid可用来查看变量类型 cout << typeid(b).name() << endl; cout << typeid(c).name() << endl; cout << typeid(d).name() << endl; return 0;}
注意：
使用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto 的实际类型。因此auto并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编译期会将auto替换为变量实际的类型。
int main(){ auto a; //要初始化 return 0;}
auto使用规则
?auto与指针和引用结合起来使用
用auto声明指针类型时，用auto和auto*没有任何区别int main(){ int x = 10; auto a = &x; auto* b = &x; cout << typeid(a).name() << endl; cout << typeid(b).name() << endl; return 0;}
int main(){ int x = 10; auto& a = x; cout << typeid(a).name() << endl; return 0;}?在同一行定义多个变量
当在同一行声明多个变量的时候，这些变量必须是相同的类型，否则编译器会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。
int main(){ auto a = 10, b = 30; auto c = 15, d = 1.5;//该行编译失败，c和d的初始化类型不同}auto无法使用的场景
?auto不能作为函数的参数
//错误，编译器无法对x的实际类型进行推导void Text(auto x){} int main(){ int a=5; Test(a); return 0;}?auto不能作返回值
auto Test(int x){}?auto不能直接用来声明数组
void Text(){ auto arr[] = { 1, 2, 3 };//错误写法 int arr[] = {1, 2, 3}//这才是正确写法}?基于范围的for循环
范围for的语法
我们在以前使用 for 遍历一个数组，会用下面这种方法：
int main(){ int arr[] = { 1,2,3,4,5 }; int size = sizeof(arr) / sizeof(arr[0]); for (int i = 0; i < size; ++i) { cout << arr[i] << " "; } cout << endl;}对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因此C++11中引入了基于范围的for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范 围内用于迭代的变量，第二部分则表示被迭代的范围。
int main(){ int arr[] = { 1,2,3,4,5 }; int size = sizeof(arr) / sizeof(arr[0]); for (auto e : arr) { cout << e << " "; } return 0;}
依次取数组arr中的每个数赋值给e，e也就是数组中每个数的拷贝，所以e的改变不会影响数组中数的改变，想要改变数组的值，要使用引用。
int main(){ int arr[] = { 1,2,3,4,5 }; int size = sizeof(arr) / sizeof(arr[0]); for (auto e : arr) { e++; cout << e << " "; } cout << endl; for (auto e : arr) { cout << e << " "; } return 0;}
范围for的使用条件
for循环迭代的范围必须是确定的迭代的对象要实现++和==的操作对于数组而言，就是数组中第一个元素和最后一个元素的范围；对于类而言，应该提供 begin 和end的方法，begin和end就是for循环迭代的范围。
注意：以下代码就有问题，因为for的范围不确定
void Text(int arr[])//arr本质上只是一个地址，没有范围{ for (auto a : arr) { cout << a << endl; }}数组不能传参，数组传参传递的是数组首元素的地址
?指针空值nullptr
在C/C++编程习惯中，我们声明一个变量时最好给该变量一个合适的初始值，否则可能会出现 不可预料的错误，比如未初始化的指针。如果一个指针没有合法的指向，我们都会把它置为空指针。
void Test(){ int* p1 = NULL; int* p2 = 0;}NULL实际是一个宏，在传统的C头文件(stddef.h)中，可以看到如下代码：
#ifndef NULL#ifdef __cplusplus#define NULL 0#else#define NULL ((void *)0)#endif#endif下面这段代码的结果是什么呢？
void f(int){ cout<<"f(int)"<<endl;} void f(int*){ cout<<"f(int*)"<<endl;} int main(){ f(0); f(NULL); f(nullptr); return 0;}
程序本意是想通过 f(NULL) 调用 f(int*) 函数，但是由于NULL被定义成0，因此与程序的初衷相悖。 在C++98中，字面常量0既可以是一个整形数字，也可以是无类型的指针(void*)常量，但是编译器默认情况下将其看成是一个整形常量，如果要将其按照指针方式来使用，必须对其进行强转(void *)0。
注意：
在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入的。 在C++11中，sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同。为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr。本次的内容到这里就结束啦。希望大家阅读完可以有所收获，同时也感谢各位读者三连支持。文章有问题可以在评论区留言，博主一定认真认真修改，以后写出更好的文章。你们的支持就是博主最大的动力。