C++ 入门

最新推荐文章于 2024-07-17 20:43:45 发布

少年没有乌托邦。

最新推荐文章于 2024-07-17 20:43:45 发布

阅读量924

点赞数 39

分类专栏： c++ 文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/m0_64364831/article/details/140088664

版权

c++ 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

C++ 入门

1. C++关键字
2. 命名空间
3.C++输入&输出
4. 缺省参数
- 4.1 缺省参数概念
- - 1.全缺省参数
  - 2.半缺省参数
5. 函数重载
6. 引用
7.内联函数
8. auto关键字(C++11)
9.基于范围的for循环(C++11)
- 9.1 范围for的语法
- 9.2 范围for的使用条件
指针空值nullptr(C++11)
- 10.1 C++98中的指针空值

C++是一种高级编程语言，由Bjarne Stroustrup在20世纪80年代初期在贝尔实验室开发。它是对C语言的扩展，添加了面向对象编程的特性，如类和对象、继承、多态和封装。C++支持多种编程范式，包括过程化、面向对象和泛型编程，这使得它成为一种功能强大且灵活的语言。
下面简单介绍下c++ 的命名空间以及输入和输出。

1. C++关键字

C++总计63个关键字，C语言32个关键字
在这里插入图片描述

2. 命名空间

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

下面请看例子：

#include <stdio.h>
#include <stdlib.h>  

int rand = 0;
int main()
{
	printf("%d", rand);
	printf("Hello World!");
	return 0;
}
// 编译后后报错：error C2365: “rand”: 重定义；以前的定义是“函数”

程序报错：因为头文件#include<stdlib.h> 展开后里面有个库函数 rand（）与我们自己定义的全局变量rand 名字一样，所以就发生了冲突。
在这里插入图片描述
C语言没办法解决类似这样的命名冲突问题，所以C++提出了namespace来解决。

2.1 命名空间定义

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

命名空间有三种定义方式：

1. 正常的命名空间定义

命名空间中可以定义变量/函数/类型
例子如下：
在这里插入图片描述

2. 命名空间可以嵌套

例子如下：
// test.cpp
在这里插入图片描述

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

如果合并了以后，他们就是同一个域，同一个域不能有同名的,如果实在有，就冲突了，解决方法是嵌套。
ps：一个工程中的test.h和上面test.cpp中两个bit 会被合并成一个
// test.h
在这里插入图片描述

namespace bit
{
 int Mul(int left, int right)
 {
     return left * right;
 }
}

注意：一个命名空间就定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中，不同作用域可以定义同名变量

例子：

在这里插入图片描述

2.2 命名空间使用

命名空间中成员该如何使用呢？比如：

#include <stdio.h>
//#include <stdlib.h>  

namespace bit  
{
	int rand = 0;
}
int main()
{
	printf("%p\n", rand);  // 编译报错：error C2065: “rand”: 未声明的标识符
	printf("Hello World!\n");
	return 0;
}

运行结果：

在这里插入图片描述

为什么会出错呢？因为我们用一个变量或者函数它要找它自己的出处，也就是找它自己的定义，找不到就会报错，错误信息就是未声明的标识符。
用一个变量/函数/类型…就要查找它的出处也就是定义在哪
编译器默认的查找顺序
a.先在当前局部域找
b. 在到全局域找
c. 不会到其他命名空间去找：隔壁张大爷家自留地

如下：因为rand 变量在局部没有定义，所以默认访问的是头文件<stdlib.h> 展开后的全局变量
在这里插入图片描述

我们要想访问命名空间里面的变量或者函数或者类型该怎么办呢？
下面介绍命名空间的使用有三种方式：

1.加命名空间名称及作用域限定符

int main()
{
printf(“%d\n”, bit::a); // :: 域作用限定符
return 0;
}

例子如下：
在这里插入图片描述

2.使用using namespace 命名空间名称引入

using namespce bit;
int main()
{
printf(“%d\n”, bit::rand);
printf(“%d\n”, b);
Add(10, 20);
return 0;
}

展开命名空间默认查找规则：
在这里插入图片描述
要是没展开命名空间的话，就不会到命名空间中查找

注意：1.全局的和展开命名空间有同名的就相当于有命名冲突，这时候就不用展开命名空间,如果把命名空间展开了，在不指定命名空间域的情况下，全局域和命名空间域会同时搜索，就会产生冲突。
例子：
在这里插入图片描述

2.若两个命名空间域里面有同名的，他们同时展开会冲突，不知道用谁的。
3.展开命名空间实际上是相当于加个声明，不是拷贝。

例子如下：

test.h
#pragma once
namespace bit
{
	int rand = 10;
	int b = 20;
	int Add(int left, int right)
	{
		return left + right;
	}
	struct Node
	{
		struct Node* next;
		int val;
	};

}
test.cpp
#include <stdio.h>
#include "test.h"
using namespace bit; //展开命名空间域bit
int main()
{
	printf("%d\n", bit::rand); 
	printf("%d\n", b);
	printf("%d\n", Add(10, 20));
	return 0;
}

运行结果：
在这里插入图片描述

3.使用using 指定展开某一个成员

using bit::x;
int main()
{
    printf("%d\n", x);
     printf("%d\n", bit::y);
    return 0;    
}

代码如下：

test.h
namespace bit
{
	int rand = 10;
	int x = 100;
	int y = 30;
	int Add(int left, int right)
	{
		return left + right;
	}
	struct Node
	{
		struct Node* next;
		int val;
	};
}
test.cpp
#include <stdio.h>
#include "test2.h"
using bit::x; //指定展开命名空间域中的变量x

int main()
{
	//x经常使用，y不长使用，所以只要展开x
	printf("%d\n", x);
	printf("%d\n", x);
	printf("%d\n", x);
	printf("%d\n", x);
	printf("%d\n", x);
	printf("%d\n", bit::y);
	return 0;
}

运行结果：
在这里插入图片描述
总结:
1.局部域会影响生命周期
2.全局域会影响生命周期
3.命名空间域修饰全局的，不会影响生命周期

1.命名空间（namespace）是一个定义了一组标识符的区域，它的作用是组织代码，避免名称冲突。命名空间不控制变量或对象的生命周期。变量或对象的生命周期是由它们的作用域（scope）决定的，而不是由命名空间决定。命名空间可以包含变量、函数、类等，但它们本身不控制这些实体的生命周期。
2.作用域（Scope）：变量的生命周期通常与其作用域有关。作用域可以是全局的、局部的、函数内的等。当作用域结束时，其中的局部变量会被销毁。
3.生命周期：对象的生命周期是指从创建到销毁的时间。这通常与对象的作用域有关，例如局部对象在作用域结束时被销毁，而全局或静态对象则在程序结束时被销毁。
4.作用域解析运算符（::）：当你需要访问不同命名空间中的同名实体时，可以使用作用域解析运算符来明确指定你想要访问的实体。

4.不同域可以定义同名的变量/函数/类型

3.C++输入&输出

在使用之前有一些说明需要提前知道如下：

使用cout标准输出对象(控制台)和cin标准输入对象(键盘)时，必须包含< iostream >头文件以及按命名空间使用方法使用std。
cout和cin是全局的流对象，endl是特殊的C++符号，表示换行输出，他们都包含在包含头文件中。
<<是流插入运算符，>>是流提取运算符。
使用C++输入输出更方便，不需要像printf/scanf输入输出时那样，需要手动控制格式。C++的输入输出可以自动识别变量类型。
实际上cout和cin分别是ostream和istream类型的对象，>>和<<也涉及运算符重载等知识，
这些知识我们我们后续才会学习，所以我们这里只是简单学习他们的使用。后面我们还有有一个章节更深入的学习IO流用法及原理。
注意：早期标准库将所有功能在全局域中实现，声明在.h后缀的头文件中，使用时只需包含对应头文件即可，后来将其实现在std命名空间下，为了和C头文件区分，也为了正确使用命名空间，规定C++头文件不带.h；旧编译器(vc 6.0)中还支持<iostream.h>格式，后续编译器已不支持，因此推荐使用 <iostream.> + std的方式。

1. #include < iostream>：这是一个预处理指令，告诉编译器在编译过程中包含标准输入输出流库 iostream 的定义和声明。这个库是C++标准库的一部分，用于处理输入和输出操作。
2. std是C++标准库的命名空间名，C++将标准库的定义实现都放到这个命名空间中,std 命名空间包含了C++标准库中的所有类、函数和对象。cout 是标准库中的一个对象，代表标准输出流。
3. cout 这是标准输出流对象，用于输出数据到控制台
4. <<是流插入运算符,用于将数据发送到 cout，从而输出到控制台。
5. using namespace std;// 展开std 命名空间，这行代码指示编译器在当前作用域中使用 std 命名空间中的所有名称，这意味着你可以在不使用 std:: 前缀的情况下直接访问 std 命名空间中的所有实体，如 cin、cout 和 endl。
6. using ::std::cout; //引入 std 命名空间中的 cout 到当前作用域

cout 标准输出流：

1.使用了 using namespace std;

例子1：
在这里插入图片描述

例子2：
在这里插入图片描述

2. 如果没有使用 using namespace std;

那么每次使用标准库中的名称时都要重复 std:: 前缀

在这里插入图片描述

3.也可以用using N::b;

使用 using 声明来引入特定的标准库名称,因此就不用使用 std:: 前缀了。

在这里插入图片描述

cin 标准输入流

例子1：
在这里插入图片描述

cin >> i >> j; //这行代码使用标准输入流 cin 从输入（通常是键盘）读取两个整数值，分别赋给变量 i 和 j。用户需要在运行程序时输入这两个数值，数值之间用空格分隔。
cout << i << " " << j << endl; 这行代码使用标准输出流 cout 将变量 i 和 j 的值输出到控制台，中间用一个空格分隔。endl 是一个特殊的流操作符，用于插入一个换行符并刷新输出缓冲区，确保输出立即显示。

例子2：
在这里插入图片描述

scanf ，printf 可以在包含的C++程序中使用而不报错，因为C++编译器通常支持C语言的输入输出函数

运行结果：
在这里插入图片描述

// ps：关于cout和cin还有很多更复杂的用法，比如控制浮点数输出精度，控制整形输出进制格式等等。因为C++兼容C语言的用法，这些又用得不是很多，我们这里就不展开学习了。后续如果有需要，我们再配合文档学习。

std命名空间的使用惯例：
std是C++标准库的命名空间，如何展开std使用更合理呢？
在日常练习中，建议直接using namespace std即可，这样就很方便。
using namespace std展开，标准库就全部暴露出来了，如果我们定义跟库重名的类型/对
象/函数，就存在冲突问题。该问题在日常练习中很少出现，但是项目开发中代码较多、规模大，就很容易出现。所以建议在项目开发中使用，像std::cout这样使用时指定命名空间 + using std::cout展开常用的库对象/类型等方式。

4. 缺省参数

4.1 缺省参数概念

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

在这里插入图片描述

1.全缺省参数

在这里插入图片描述

2.半缺省参数

在这里插入图片描述

注意

半缺省参数必须从右往左依次来给出，不能间隔着给
缺省参数不能在函数声明和定义中同时出现，它们分离的时候以声明为主
3. 缺省值必须是常量或者全局变量
4 . C语言不支持（编译器不支持）

5. 函数重载

自然语言中，一个词可以有多重含义，人们可以通过上下文来判断该词真实的含义，即该词被重载了。
比如：以前有一个笑话，国有两个体育项目大家根本不用看，也不用担心。一个是乒乓球，一个是男足。前者是“谁也赢不了！”，后者是“谁也赢不了！”

5.1 函数重载概念

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

//test.c
void Swap(int* pa, int* pb)
{

}
void Swap(double* pa, double* pb)
{

}
int main()
{
	return 0;
}

运行结果：

在这里插入图片描述
c++ 支持同名函数
例子如下：

下面给出在 c++ 中同名函数的具体例子：

1.参数类型不同

在这里插入图片描述

注意
不同作用域可以同名，但是同一作用域也可以同名，但是要满足重载规则。
例子如下：

//不同作用域可以同名
namespace bit1
{
	void Swap(int* pa, int* pb)
	{
		cout << "void Swap(int* pa, int* pb)" << endl;
	}
}
namespace bit2
{
	void Swap(int* pa, int* pb)
	{
		cout << "void Swap(int* pa, int* pb)" << endl;
	}
}
//同一作用域 可以同名 满足重载规则
void Swap(double* pa, double* pb)
{
	cout << "void Swap(double* pa, double* pb)" << endl;
}
using namespace bit1;
using namespace bit2;
//展开之后 它们俩不是重载关系，还是在各自的作用域，展开不是让他们变成同一个域
int main()
{
	int a = 0, b = 1;
	double c = 0.1, d = 1.1;
	Swap(&a,&b);  //出错是因为调用歧义，不知道先调用哪个
	Swap(&c,&d);
	return 0;
}

运行结果：
在这里插入图片描述

2. 参数个数不同

在这里插入图片描述

3.参数类型顺序不同

在这里插入图片描述

5.2 C++支持函数重载的原理–名字修饰(name Mangling)

为什么C++支持函数重载，而C语言不支持函数重载呢？
结论：如果函数声明和定义分离，在链接的时候就要用函数名去找地址，c语言直接用函数名去找，不支持函数重载，没办法区分。c++是通过函数修饰规则来区分，只要参数不同，修饰出来的名字就不一样，就支持了重载。
图示：
在这里插入图片描述
注意：如果两个函数函数名和参数是一样的，返回值不同是不构成重载的，因为调用时编译器没办法区分。

6. 引用

6.1 引用概念

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。

下面是语法规则：

类型& 引用变量名(对象名) = 引用实体；

1.给变量 a取别名

在这里插入图片描述

2.也可以给别名取别名

例子：

在这里插入图片描述

3.给指针取别名

#include<iostream>
using namespace std;
int mian()
{
	int x = 0;
	int* p1 = &x;
	int*& pr = p1;  //给指针变量取别名
	pr = NULL; // pr，p1 指向的是同一块空间
}

调试过程：
在这里插入图片描述

注意：

& 符号 在定义的时候是引用，但是在其他地方就是取地址。
引用类型必须和引用实体是同种类型的

6.2 引用特性

1. 引用在定义时必须初始化

例子：
在这里插入图片描述

2. 一个变量可以有多个引用

例子：
在这里插入图片描述

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

例子：
在这里插入图片描述

6.3 常引用

1.权限的使用

在这里插入图片描述
结论：

1.值之间没有权限放大缩小的概念，只有赋值的概念。
2.引用和指针有权限放大缩小的概念。权限不能放大，只能缩小

2.临时变量具有常性

在这里插入图片描述
结论：类型转换中间会生成临时变量，表达式运算中间也会产生临时变量
下面有两个例子解释：

double d = 12.34;
int i = d;
双精度浮点数变量d 赋值给整形变量 i 中间会产生临时变量，浮点数的存储规则：整数部分+小数部分，类型转换是把整数部分取出来，按规则语法上理解，先会把整形给临时变量，再把临时变量里面存储的值给整形变量i。

double d = 12.34;
const int& r1 = d;
d 给给 r1 ，是有类型转换的，类型转换会产生临时变量，把d里面的整形取出来给临时变量，那r引用的就是临时变量，又因为临时变量具有常性，不能被修改，这属于权限的放大，所以要加前面const 修饰才正确。

6.4 使用场景

1. 做参数

例子1：

在这里插入图片描述

例子2：

在这里插入图片描述

例子3：
在这里插入图片描述

6.5 传值、传引用效率比较

以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低。

例子1：

在这里插入图片描述

结果分析：
1.传值传参是有一定的消耗的,尽可能的避免传值传参。
2.以引用作为函数参数，函数运行结束后的时间小于1毫秒。效率比传值传参的效率高。

6.6 引用和指针的区别

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

但是在底层反汇编中引用跟指针是一样的都要开空间，也就是说转换成汇编以后就没有引用这个概念了，都是指针。但是在日常中谈论，我们认为引用不开空间，指针开空间。

上图代码反汇编图示：
在这里插入图片描述
引用和指针的不同点：

引用概念上定义一个变量的别名，指针存储一个变量地址。
引用在定义时必须初始化，指针没有要求（可以初始化，也可以不初始化）。
引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体。
没有NULL引用，但有NULL指针（这句话是相对的）。
例子如下：

底层反汇编：
在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)。
引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小。
有多级指针，但是没有多级引用。
访问实体方式不同，指针需要显式解引用，引用编译器自己处理。
引用比指针使用起来相对更安全(c++中通常推荐使用引用，但引用不能完全替代指针)。

在链表中，由于链表的动态特性，节点可能会被插入或删除，节点通常包含两个部分：数据部分和指向列表中下一个节点的指针部分，因此需要能够改变指针的指向，这时用到的就是指针，为什么不用引用，因为引用不能改变指向。

7.内联函数

7.1 为什么会产生内联函数

首先会面对这样的一个问题，如果这里有频繁调用的小函数，比如说Swap(),这个函数在排序中用到很多，排一百万个数据，得Swap()多少次呢？可能要调几千万次Swap()，但是每次用Swap()函数是就会付出一定的代价，每次调用都会在建立栈帧，建立栈帧是有消耗的。那这种小函数能不能不建立栈帧呢，有什么方法可以缓解这个问题？
c语言是使用宏解决的，宏有两个，一个是常量，另一个是宏函数，本质上是用宏函数解决。但是宏函数易出错，因此需要少用。在c++中祖师爷忌讳用宏函数。
下面是一个Add()函数用宏函数的写法：
在这里插入图片描述
宏是直接替换的，所以没有栈帧消耗，但是宏也容易出各种坑，因此祖师爷专门搞个内联函数来解决这个问题。

7.2 概念

以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数调用建立栈帧的开销，内联函数提升程序运行的效率。
下图是函数体里面的逻辑没有在函数调用的地方展开
在这里插入图片描述 Debug版本下默认是不展开的
两种方法可以解决上述问题：
1.在debug模式下，需要对编译器进行设置，否则不会展开(因为debug模式下，编译器默认不会对代码进行优化，以下给出vs2022的设置方式)

接下来我们再来看一下底层反汇编
在这里插入图片描述
可以看到没有call ,展开以后减少了空间消耗.
2. 在release模式下，查看编译器生成的汇编代码中是否存在call Add.

7.3 特性

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

这有一个函数，这个函数展开之后需要100行指令，如果有10000个调用的地方，展开和不展开在这里的消耗分别是什么?
如果不展开，这个函数本身就占用100行指令，10000个调用地方就是10000个call，call这个地址，每次调用时候，就跳转过来去执行这100行,也就是
10000+100.
如果展开,那10000个调用的地方要把这100行拿过来,因此是10000*100.

大函数展开会导致编译出来的可执行程序变大,可执行程序变大会带来内存占用增加,网络传输时间增加等一系列坏处.

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

解决方法是:
声明和定义不分离,直接在F.h中定义

test.cpp 包了#include “F.h” ，直接就有定义，就直接在调用的时候展开，就不需要call 了.

宏的优缺点？

优点：
1.增强代码的复用性。
2.提高性能。
缺点：
1.不方便调试宏。（因为预编译阶段进行了替换）
2.导致代码可读性差，可维护性差，容易误用。
3.没有类型安全的检查。

C++有哪些技术替代宏?

const enum(枚举) 替代宏常量
内联函数替代宏函数

8. auto关键字(C++11)

8.1auto语法

使用auto 是右边初始化自动推导类型
auto可以替代写起来比较长的类型的定义，简化代码

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

但这些影响都不是很大,总之auto用起来更方便.
通过 typeid(变量).name() 可以去看变量的类型

8.2auto的使用细则

1. auto与指针和引用结合起来使用
用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&
在这里插入图片描述

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

8.3 auto不能推导的场景

1. auto不能作为函数的参数
auto做参数不知道形参的类型,函数栈帧就不知道开多大,因为栈帧里面要存局部变量和形参,编译的时候就要转成汇编指令,就要确定开多大.

void TestAuto(auto a)
{}

2. auto不能直接用来声明数组
在这里插入图片描述
3. 为了避免与C++98中的auto发生混淆，C++11只保留了auto作为类型指示符的用法.
4. auto在实际中最常见的优势用法就是跟以后会讲到的C++11提供的新式for循环，还有lambda表达式等进行配合使用。

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

9.1 范围for的语法

在这里插入图片描述
范围for 不支持倒着遍历以及从中间遍历等.

9.2 范围for的使用条件

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

在这里插入图片描述
2. 迭代的对象要实现++和==的操作。(关于迭代器这个问题，以后会讲，现在提一下，没办法讲清楚，现在大家了解一下就可以了)

指针空值nullptr(C++11)

10.1 C++98中的指针空值

在良好的C/C++编程习惯中，声明一个变量时最好给该变量一个合适的初始值，否则可能会出现不可预料的错误，比如未初始化的指针。如果一个指针没有合法的指向，我们基本都是按照如下方式对其进行初始化：
在这里插入图片描述
NULL实际是一个宏，在传统的C头文件(stddef.h)中，可以看到如下代码：

可以看到，NULL可能被定义为字面常量0，或者被定义为无类型指针(void*)的常量。不论采取何种定义，在使用空值的指针时，都不可避免的会遇到一些麻烦，比如：
程序本意是想通过f(NULL)调用指针版本的f(int*)函数，但是由于NULL被定义成0，因此与程序的初衷相悖。
在这里插入图片描述

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

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