C++：快速入门篇

水深无声 2024-02-20 08:25 84阅读 0赞

![209c48d1a63a42a1816c5c83e3042b35.png][]

> C++:.cpp(面向对象)
> 
> C语音：.c(面向过程)是为了弥补C的不足
> 
> 命名冲突：
> 
> 1.写的跟库冲突
> 
> 2.自己写的互相冲突

## 1.命名空间 ##

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

#include <stdio.h>
    #include <stdlib.h>
    
    //全局变量
    int rand = 100;
    
    int main()
    {
        printf("%d\n", rand);
        return 0;
    }

> 上面的代码运行打印出来的是什么呢？
> 
> 在上面的代码运行中，打印出来的是一串数字。
> 
> 我定义的是全局变量rand，为什么打印的是数字呢？
> 
> 因为在<stdlib.h>中有一个rand()函数，以整形打印就是一串数字。
> 
> **C语言没办法解决类似这样的命名冲突问题，所以C++提出了namespace来解决！**

### 1.1.命名空间的定义与应用： ###

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

>  **:: 域作用限定符**
> 
> 在头文件加上：using namespace std 表示此页面下的关键字都**优先使用库函数中的关键字。**
> 
> 而在我们自己定义了一个命名空间后，就可以在头文件上包含：
> 
> 例如：下方代码里定义的N1，此时我们在头文件直接：**using namespace N1**；就可以在代码块中直接应用而**不需要加N1::**了。

#### 第一种：命名空间中定义变量/函数/类型 ####

namespace N1
    {
        // 命名空间中可以定义变量/函数/类型
        int rand = 100;
    }
    
    int main()
    {
        printf("%d\n", N1::rand);
        return 0;
    }

#### 第二种：命名空间的嵌套 ####

namespace N1
    {
        int rand = 100;
    
        namespace N2
        {
            int rand = 200;
        }
    }
    
    int main()
    {
        printf("%d\n", N1::rand);
        printf("%d\n", N2::rand);
        return 0;
    }

#### 第三种：定义相同的命名空间(同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中) ####

namespace N1
    {
        int num = 300;
    }
    
    namespace N1
    {
        int rand = 100;
    }
    
    int main()
    {
        printf("%d\n", N1::num);
        printf("%d\n", N2::rand);
        return 0;
    }

> 注意：一个命名空间就定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中。

## 2.输入和输出： ##

#include <iostream>
    // std是C++标准库的命名空间名，C++将标准库的定义实现都放到这个命名空间中
    //我们自己在测试时可以直接包含标准库，在公司中一般是不直接包含，可能会造成重名出错
    using namespace std;
    
    int main()
    {
        cout<<"Hello world!!!"<<endl;
        return 0;
    }

> **说明：  
> 1.** 使用cout标准输出对象(控制台)和cin标准输入对象(键盘)时，必须包含< iostream >头文件以及按命名空间使用方法使用std。  
>  **2.** cout和cin是全局的流对象，endl是特殊的C++符号，表示换行输出，他们都包含在包含<iostream >头文件中。  
> **3. <<是流插入运算符，>>是流提取运算符。**  
>  **4.** 使用C++输入输出更方便，不需要像printf/scanf输入输出时那样，需要手动控制格式。C++的输入输出**可以自动识别变量类型。**  
>  **5.** 实际上cout和cin分别是ostream和istream类型的对象，>>和<<也涉及运算符重载等知识，这些知识我们我们后续才会学习，所以我们这里只是简单学习他们的使用。

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

//指定展开
    using std::cout;
    using std::endl;

## 3.缺省参数： ##

### 概念： ###

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

void Func(int a = 0)
    {
        cout<<a<<endl;
    }
    int main()
    {
        Func(); // 没有传参时，使用参数的默认值
        Func(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, int c = 20)
    {
        cout<<"a = "<<a<<endl;
        cout<<"b = "<<b<<endl;
        cout<<"c = "<<c<<endl;
    }

> **注意：**
> 
>  **1. 半缺省参数必须从右往左依次来给出，不能间隔着给；**  
> **2.** 缺省参数**不能在函数声明(头文件.h)和定义(.cpp)中同时出现**；
> 
>  **3.** 缺省值必须是常量或者全局变量；  
> **4.** C语言不支持（编译器不支持）

## 4.函数重载 ##

### 概念： ###

> 函数重载：是函数的一种特殊情况，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()
    {
        Add(10, 20);
        Add(10.1, 20.2);
    
        return 0;
    }

#### 参数个数不同： ####

void f()
    {
        cout << "f()" << endl;
    }
    
    void f(int a)
    {
        cout << "f(int a)" << endl;
    }
    
    int main()
    {
    
        f();
        f(10);
    
        return 0;
    }

#### 参数顺序不同： ####

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()
    {
        f(10, 'a');
        f('a', 10);
        return 0;
    }

### C++支持重载的原理----名字修饰 ###

> 在C/C++中，一个程序要运行起来，需要经历以下几个阶段：**预处理、编译、汇编、链接。**

![2f7659ce0d8246708955091045ac0f43.png][]

> **预处理：头文件展开、宏替换、条件编译、去注释 ……**
> 
> 此时生成 Func.i(函数声明和定义) Test.i(函数声明和实际调用函数)
> 
> **编译：检查语法、生成汇编代码**
> 
> 此时 Func.i ->Func.s Test.i->Test.s
> 
> ![1e84a704352645cb9ea5752beb135163.png][]![402372bbdf434454a16746191420440d.png][]
> 
> **汇编：转换成二进制的机器码**
> 
> 此时 Func.s->Func.o Test.s->Test.o
> 
> **链接：将Func..o和Test.o和并成a.out，链接一些没有确定地址的函数……**
> 
> 在C语言链接函数地址时，就用函数名去找。(C语言中不存在同名函数)；
> 
> 补充知识：
> 
> Linux 函数名修饰规则：
> 
> \_Z + 函数名字符个数 + 函数名 + 参数类型首字母
> 
> ![e70c1d0dc07f495ba3c31ab171debfcc.png][]
> 
> 在**Linux**下进行操作：
> 
> C语言编译器编译：
> 
> ![a24a2a6d761f438192f5861680c4e6fc.png][]
> 
> C++编译器编译：
> 
> ![2b702cd60e6e4a97a5490ec1a91c2ac1.png][]
> 
> **结论：**
> 
> 在linux下，采用gcc编译完成后，函数名字的修饰没有发生改变。
> 
> 在linux下，采用g++编译完成后，函数名字的修饰发生改变，编译器将函数参  
> 数类型信息添加到修改后的名字中。
> 
> Windows下名字修饰规则：
> 
> ![9c533811e29641f8bfd1a70c6fc1f7bb.png][]

> **1.**通过这里就理解了**C语言没办法支持重载**，因为**同名函数没办法区分**。而**C++是通过函数修饰规则来区分，只要参数不同，修饰出来的名字就不一样，就支持了重载。**
> 
>  **2.**如果两个函数函数名和参数是一样的，返回值不同是不构成重载的，因为调用时编译器没办法区分。

## 5.引用 ##

### 概念： ###

> 引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。
> 
> 比如：
> 
> 孙悟空(原名)--->弼马温(别名)
> 
> 齐天大圣(别名)--->大圣(别名的简称)

> **格式：类型& 引用变量名(对象名) = 引用实体**
> 
>     #include <iostream>
>     using namespace std;
>     
>     int main()
>     {
>     	int a = 1;
>     	int b = a;
>     
>     	int& c = a;
>     	int& d = a;
>     	int& e = c;
>     
>     	cout << &a << endl;
>     	cout << &c << endl;
>     	cout << &d << endl;
>     	cout << &e << endl;
>     
>     	return 0;
>     }
> 
> **注意：引用类型必须和引用实体是同种类型的**

### 特性： ###

> **1.** 引用在**定义时必须初始化**  
> **2.** 一个变量可以有多个引用  
> **3.** 引用一旦引用一个实体，再不能引用其他实体(**不能改变引用对象**)

void TestRef()
    {
        int a = 10;
        // int& ra; // 该条语句编译时会出错(没有初始化)
        int& ra = a;
        int& rra = a;
        printf("%p %p %p\n", &a, &ra, &rra);
    }

### 常引用： ###

void TestConstRef()
    {
        
        const int a = 10;
        //权限不能放大
        //int& ra = a; // 该语句编译时会出错，a为常量
        const int& ra = a;
    
        // int& b = 10; // 该语句编译时会出错，b为常量
        const int& b = 10;
        
        //权限可以缩小
        double d = 12.34;
        //int& rd = d; // 该语句编译时会出错，类型不同
        const int& rd = d;
    }

> **1.**权限不能放大；
> 
> **2.**权限可以缩小。

### 使用场景： ###

#### 做函数参数： ####

void Swap(int& left, int& right)
    {
        int temp = left;
        left = right;
        right = temp;
    }

#### 做函数返回值： ####

int& Count()
    {
        static int n = 0;
        n++;
    
        return n;
    }

下面是一个有问题的代码，这里不能用引用返回，否则为一个不确定的值有问题的代码:

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;//3
        Add(3, 4);
        cout << "Add(1, 2) is :"<< ret <<endl;//7
        return 0;
    }

![2f6c81931cd34870899f728c8af090f4.png][]

> **在这里返回值应该是不确定，取决于是否清理栈帧！！！**
> 
> **由于我们这里是用VS编译器进行编译，在VS出栈没有清理栈帧，所以导致这里打印出的是需要的到的值！**
> 
> 注意：如果函数返回时，出了函数作用域，如果返回对象还在(还没还给系统)，则可以使用  
> 引用返回，如果已经还给系统了，则必须使用传值返回。

> 问：什么时候才能用引用返回呢？
> 
> 答：出了作用域，没有被销毁才能用：**静态变量，malloc开辟的…**…

### 扩展知识(类型替换)： ###

> 例如：
> 
> int a = 10;
> 
> double b = a;
> 
> 此时**类型的改变过程中会创建一个临时变量**，记录类型改变后的值，原来的值( a )不改变。
> 
> ![f0b4c28b6c6b49788ba64166eb3e2818.png][]

### 传值、传引用效率比较： ###

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

#### 值和引用的作为参数的性能比较： ####

#include <time.h>
    struct A { int a[10000]; };
    
    void TestFunc1(A aa) {}
    
    void TestFunc2(A& aa) {}
    
    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();
    
    	// 分别计算两个函数运行结束后的时间
    	cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
    	cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
    }

#### 值和引用的作为返回值类型的性能比较： ####

#include <time.h>
    struct A { int a[10000]; };
    
    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()
    {
        int a = 10;
        int& ra = a;
        cout<<"&a = "<<&a<<endl;
        cout<<"&ra = "<<&ra<<endl;
    
        return 0;
    }

> **在底层实现上实际是有空间的，可以通过汇编来观察引用是按照指针方式来实现的。**

int main()
    {
        int a = 10;
        int& ra = a;
        ra = 20;
        int* pa = &a;
        *pa = 20;
    
        return 0;
    }

![b2e14921250c467299ff3304a5bfdecb.png][]

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

## 6.内联函数： ##

### 概念： ###

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

![45d19314aee6435387efd5b4db796ed3.png][]

> 可以看到在没有添加关键字inline前是过地址去调用Add函数，而加了inline关键字后是内联函数，**在编译期间编译器会将函数体与函数调用进行替换到Add()调用的位置，此时就是Add函数展开，就不需要压栈。**

### 特性： ###

>  **1.** inline是一种**以空间换时间**的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用，**缺陷：可能会使目标文件变大，优势：少了调用开销，提高程序运行效率。**  
>  **2.** i**nline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不是递归、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。**
> 
> **3. inline不建议声明和定义分离**，分离会导致链接错误。**因为inline被展开，就没有函数地址了**，链接就会找不到。

### 举例： ###

> 此时打开反汇编就可以看到，函数调用没有被替换，而是根据函数地址去调用了函数，说明**编译器的优化将较长的函数调用忽略，继续采用函数调用。**

inline int Add(int x, int y)
    {
    	int c = x + y;
    	int c1 = x + y;
    	int c2 = x + y;
    	int c3 = x + y;
    	int c4 = x + y;
    	int c5 = x + y;
    	int c6 = x + y;
    	int c7 = x + y;
    	int c8 = x + y;
    	int c9 = x + y*c8;
    	int c10 = x + y;
    	int c11 = x + y;
    	return c1+c10-c9;
    }
    
    int main()
    {
    	int ret1 = Add(1, 2);
    	int ret3 = Add(1, 2);
    
    
    	// 优点：不用建立栈帧，提高效率
    	int ret2 = ADD(1, 2);
    
    	return 0;
    }

### 扩展知识： ###

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

> C++有哪些技术替代宏？  
>  **1.** 常量定义 换用const enum  
>  **2.** 短小函数定义 换用内联函数  
>  **enum const inline 替代宏  
> enum const -> 宏常量  
> inline ->宏函数**

## 7.auto 关键字 ##

### 类型别名的由来： ###

> 随着程序越来越复杂，程序中用到的类型也越来越复杂，经常体现在：  
> **1.** 类型难于拼写
> 
> **2.** 含义不明确导致容易出错

#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<std::string, std::string>::iterator**是一个类型，由于类型太长，可以使用typedef给类型取一个别名，但是这样在编程时，常常需要把表达式的值赋值给变量，这就要求在声明变量的时候清楚地知道表达式的 类型。然而有时候要做到这点并非那么容易，因此C++11给auto赋予了新的含义。

### auto简介： ###

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

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

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

### auto的使用规则： ###

#### auto与指针和引用的结合使用： ####

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

#include <iostream>
    using namespace std;
    
    
    int main()
    {
        int x = 10;
        auto a = &x;
        auto* b = &x;
        auto& c = x;
        cout << typeid(a).name() << endl;
        cout << typeid(b).name() << endl;
        cout << typeid(c).name() << endl;
        *a = 20;
        *b = 30;
         c = 40;
        return 0;
    }

#### 在同一行定义多个变量： ####

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

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

### auto不能推导的场景： ###

**1.**auto不能作为函数的参数，不能作为函数返回值：

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

**2.**auto不能直接用来声明数组：

void TestAuto()
    {
        int a[] = {1,2,3};
        auto b[] = {4，5，6};
    }

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

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

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

### 范围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 << " ";
        return 0;
    }

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

### 范围for的使用条件： ###

**1.for循环迭代的范围必须是确定的：**

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

**注意：**以下代码就有问题，因为**for的范围不确定！**

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

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

## 9.指针空值nullprt(C++11) ##

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

void TestPtr()
    {
        int* p1 = NULL;
        int* p2 = 0;
        // ……
    }

**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(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。**

#### 以上就是个人学习的个人见解和学习的解析，欢迎各位大佬在评论区探讨，矫正！ ####

#### 感谢大佬们的一键三连！ 感谢大佬们的一键三连！ 感谢大佬们的一键三连！ ####

![7bad9f1ed1b44b53b34d043644d9965a.png][]

[209c48d1a63a42a1816c5c83e3042b35.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/20/b3926fe5275a44b6aed73abc896af591.png
[2f7659ce0d8246708955091045ac0f43.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/20/f158adb0a03d43a1919b16e0d420380e.png
[1e84a704352645cb9ea5752beb135163.png]: https://img-blog.csdnimg.cn/1e84a704352645cb9ea5752beb135163.png
[402372bbdf434454a16746191420440d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/20/3c85c248545e400eb7b0a85c1ff9f63e.png
[e70c1d0dc07f495ba3c31ab171debfcc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/20/8ccff21b2fa3443ab4831c1f27572ba4.png
[a24a2a6d761f438192f5861680c4e6fc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/20/8dcf89fbaa7b41db9272ff145f0fff61.png
[2b702cd60e6e4a97a5490ec1a91c2ac1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/20/51f0a91c95924f41a07e46e11c193500.png
[9c533811e29641f8bfd1a70c6fc1f7bb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/20/fcead43b430c410abf9b11a896cf2c99.png
[2f6c81931cd34870899f728c8af090f4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/20/f5d9c9ee41c54c71bba69f6c66b4ac53.png
[f0b4c28b6c6b49788ba64166eb3e2818.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/20/ece9cb8a5f044609871d8277828943fc.png
[b2e14921250c467299ff3304a5bfdecb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/20/9b5a34b845454f8aa35d36ccb61729c4.png
[45d19314aee6435387efd5b4db796ed3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/20/d5e86e2f5b704bf1a57620ad1e10d0ac.png
[7bad9f1ed1b44b53b34d043644d9965a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/20/93fc427e397f4a49889f3e8faf2ebdb6.png