面试官：指针都不会，我们不需要你这样的人！

我不是女神ヾ 2023-02-09 13:18 86阅读 0赞

> 上周，学弟在一个面试中，被考官问到了`有关指针`的问题。然鹅，学弟说了半天，最终也`没能让考官满意`。为此我还替他捏了一把冷汗！鉴于此，今天我来写一篇关于指针的初级干货，让你在面试官前`有得扯，并扯清楚`！

### 文章目录 ###

*   *  1. 初识指针
     *   *  (1) 声明指针
         *  (2) 使用 & 获取变量地址
         *  (3) 使用指针存储地址
         *  (4) 使用 \* 访问指向的数据
     *  2. 动态内存分配
     *   *  (1) new/delete动态分配和释放内存
         *  (2) 带关键字const的指针
         *  (3) 指针 VS 数组
     *  3. 使用指针时的常见错误
     *   *  (1) 内存泄漏
         *  (2) 无效指针

## 1. 初识指针 ##

什么是指针呢？想想，我们脑海里的指针大概长什么样：

![在这里插入图片描述][20200519132914110.jpg_pic_center]  
这样？那我们今天就来聊一聊“指针”表的使用方法吧！

![在这里插入图片描述][20200519140846763.jpg_pic_center]  
咳咳，不开玩笑了!  
在编程语言中，指针可比你上面能看到的“指针”抽象得多。所以在学习时，我们往往知道有指针这么个东西，但是又迷迷糊糊不知道怎么用它。下面，我就来带大家直观地感受一下什么是指针！

简单来说，指针是一种特殊的变量。特殊在于，这种变量存储的不是普通值（比如1，2，100，‘q’）；它存储的是内存地址，比如0x101、0x886等。

不理解也没关系，下面我画了一张示意图，让大家直观地看一下什么是指针：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dqaW5qaWU_size_16_color_FFFFFF_t_70_pic_center]  
注：图中的0x886等都是为方便说明假定的虚拟地址。

我们都知道，变量的存储是需要占用内存空间的。  
图中，Age是一个变量，它的存放地址是0x886，存放的值是18。  
pAge是一个指针，也可以说是一个特殊的变量。它的存放地址是0x601，存放的内容是0x886。

对比，很容易发现，指针和变量有很多相似之处；不同之处在于，指针存放的是内存地址。

再仔细观察一下，可以发现：指针pAge中存储的地址=变量Age的内存地址。因此也可以说，指针pAge是指向内存单元Age的特殊变量。

相信说到这里，大家对指针已经有一个直观地认识了。那么我们如何去使用它呢？  
掌握下面四个部分，大家就可以轻松上手指针了：

1.  声明指针
2.  使用 & 获取变量地址
3.  使用指针存储地址
4.  使用 \* 访问指向的数据

下面我们就来分别学习这四个部分吧！

### (1) 声明指针 ###

指针作为一种特殊变量，也是需要声明的。我们先回忆下，之前在[【C++养成计划】深入浅出——变量作用域（Day3）][C_Day3]中，我们是如何声明一个int类型变量的：

int Age; //声明一个变量Age

在声明指针时，也需要指明类型。而该类型，比如int，对应的是该指针指向内存单元中存储的数的类型。

int *pAge; //声明一个指针变量

在声明变量时，我们一般会将变量初始化为0。同样，在声明指针时，我们也不希望它指向随机的内存单元。因此会将指针初始化为NULL。

int Age = 0;
    int *pAge = NULL;

注：初始化为NULL的指针被称为NULL指针或空指针，空指针（即pAge）是一个定义在标准库中的值为零的常量。

### (2) 使用 & 获取变量地址 ###

符号 & 被称为`引用运算符`。如果Age表示一个变量，&Age将是存储该变量的内存地址。  
下面，我们举一个简单的例子，来获取变量Age的地址：

#include<iostream>
    using namespace std;
    int main()
    { 
    	int Age=18;
    	cout<<"变量Age存放在内存中的地址是："<<hex<<&Age<<endl;
    	return 0;
    }

运行后输出结果：  
![在这里插入图片描述][20200519162413949.PNG_pic_center]  
注：程序中的hex，是为了输出的格式为16进制，这是地址表示的一种约定。

### (3) 使用指针存储地址 ###

我们知道了指针是用于存储内存地址的变量，也知道了如何声明指针以及获取变量的地址。现在就可以将它们关联起来，使用指针来存储 & 获取的地址。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dqaW5qaWU_size_16_color_FFFFFF_t_70_pic_center 1]  
如上图所示，这次我们就可直接通过&Age获取地址，将其传给指针pAge。  
下面举一个小例子，来声明和初始化指针。

#include<iostream>
    using namespace std;
    int main()
    { 
    	int Age = 18;
    	cout<<"变量Age存放在内存中的地址是："<<hex<<&Age<<endl;
    	int *pAge = &Age;
    	cout<<"指针pAge中存放的地址是："<<hex<<pAge<<endl;
    	return 0;
    }

运行结果：  
![在这里插入图片描述][20200519164835442.PNG_pic_center]  
可见，变量Age存放在内存中的地址=指针pAge中存放的地址。说明引用运算符 & 取到了Age的内存地址，并传给了指针pAge。

### (4) 使用 \* 访问指向的数据 ###

符号 \* 也被称为`解除引用运算符`。通常，只要是合法的指针pAge，我们就可以通过 \*pAge 访问`指针pAge包含的地址处存储的值`。（注意是访问地址所对应的值，而不是地址）  
下面，举一个简单的例子：

#include<iostream>
    using namespace std;
    int main()
    { 
    	int Age = 18;
    	cout<<"Age = "<<Age<<endl;
    	int *pAge = &Age;
    	cout<<"*pAge = "<<*pAge<<endl; 
    	return 0;
    }

运行结果：  
![在这里插入图片描述][20200519170323389.PNG_pic_center]  
简单来说，指针pAge是指向变量Age对应的内存单元的，所以通过符号 \* 就可以获得Age对应的值。

--------------------

> 这里是一段防爬虫文本，请读者忽略。 本文原创首发于 CSDN，作者【AI 菌】。  
> 博客首页：[https://blog.csdn.net/wjinjie][https_blog.csdn.net_wjinjie]  
> 本文链接：[https://ai-wx.blog.csdn.net/article/details/107509243][https_ai-wx.blog.csdn.net_article_details_107509243]  
> 未经授权，禁止转载！恶意转载，后果自负！尊重原创，远离剽窃！

--------------------

## 2. 动态内存分配 ##

为了帮助开发者更好地管理应用程序占用的内存，C++提供了两个运算符：new和delete。指针是包含内存地址的变量，在高效分配内存方面扮演了重要的角色。

### (1) new/delete动态分配和释放内存 ###

当你使用new来分配内存块时，如果成功，new将返回指向一个指针，指向一个分配的内存，否则将引发异常。  
使用new为一个int类型的数分配内存：

int *pNum = new int;

使用new为多个元素分配内存：

int *pNums = new int[10];

注：new请求分配内存时，并不能保证请求总能得到满足，因为这取决于系统的状态以及内存资源的可用性。

使用new分配的内存最终都需要使用对应的delete进行释放：

1.  对于一个元素的情况：

int *pNum = new int;  //分配内存空间
    -----程序块-----
    delete pNum;  //释放内存空间

1.  多个元素的情况

int *pNums = new int[10];  //分配内存空间
    -----程序块-----
    delete[] pNUms;  //释放内存空间

注：不再使用分配的内存后，一定要通过delete释放，否则可能出现内存泄漏。

下面举一个简单的例子：开辟一个内存空间来存放年龄，在输出存储年龄的内存地址后，再释放分配的内存空间。

#include<iostream>
    using namespace std;
    int main()
    { 
    	int *pAge = new int;
    	cout<<"请输入您的年龄：";
    	cin>>*pAge;
    	cout<<"存储年龄的内存地址是："<<hex<<pAge<<endl;
    	delete pAge;
    	return 0;
    }

运行结果：  
![在这里插入图片描述][20200519190452629.PNG_pic_center]

### (2) 带关键字const的指针 ###

在前面[【C++养成计划】深入浅出——变量作用域（Day3）][C_Day3 1]中讲过，将变量声明为const时，变量的取值在整个生命周期内固定为初始值。这种变量的值是不能修改的。  
指针也是变量，因此也可以将const用于指针。const指针有以下三种：

1.  指针指向的数据为常量，不能修改。但可以修改指针包含的地址，即指针可以指向其他地方。

1.指针指向的数据为常量
    int Age = 18;
    const int *pAge = &Age;  //不能更改pAge指向的数据Age的值
    
    2. 想将Age改为20，错误的做法
    *pAge = 20;  //错误
    
    3. 正确的做法
    int CopyAge = 20;
    pAge = &CopyAge; //可改变指针指向的地址

1.  指针包含的地址是常量，不能修改，单可修改指针指向的数据。

int Age = 18;
    int* const pAge = &Age;
    *pAge = 20; //做法正确，可以改变值

1.  指针包含的地址以及他指向的值都是常量，因此都不能修改。

int Age = 18;
    const int* const pAge = &Age;

### (3) 指针 VS 数组 ###

当我们声明一个数组时，比如下面这样：

int Array[10];

编译器将分配固定的内存，用于存储10个整数。同时向你提供一个指向数组中第一个元素的指针。换句话说，Array是一个指针，指向第一个元素Array\[0\]。下面程序演示了这种关系：

#include<iostream>
    using namespace std;
    int main()
    { 
    	int Array[10]={ 0,1,2,3,4,5,6,7,8,9};
    	int *pNum = Array;
    	cout<<"*pNum = "<<*pNum<<endl;
    	cout<<"Array[0] = "<<Array[0]<<endl; 
    	return 0;
    }

运行结果：  
![在这里插入图片描述][2020051919401694.PNG_pic_center]  
由此可见，数组名是一个指针，且指向第一个元素。

## 3. 使用指针时的常见错误 ##

### (1) 内存泄漏 ###

如果在使用new动态分配的内存不再需要后，开发者没有及时使用delete释放内存的话，这些内存就会被预留并分配给你的应用程序。这将减少可供其他应用程序使用的系统内存量，甚至会降低应用程序的执行速度，这就是所说的`内存泄漏`。  
比如下面这样：

int* pNums = new int[10];
    -----程序块-----
    //忘记进行delete[]

忘记对已经请求分配的内存进行delete，很容易造成内存泄漏，我们在使用new请求分配动态内存时，一定要注意这个。

### (2) 无效指针 ###

使用运算符 \* 对指针解除引用，以访问指向的值时。务必确保该指针指向了有效的内存单元，否则程序很可能崩溃。  
导致指针无效的原因很多，但都要归结于糟糕的内存管理。这里仅介绍两种常见的引起指针无效的情形：

1.  声明指针过程中，没有将其初始化为NULL，并且在后面也没有对指针赋以有效的地址。
2.  使用new为指针申请动态内存时，当内存需要量特别大时，可能分配不成功，导致无效指针。比如下面这样：

int* pNums = new int[10000000000]; //申请的内存量太大，可能导致分配不成功

--------------------

***由于水平有限，博客中难免会有一些错误，有纰漏之处恳请各位大佬不吝赐教！***

![在这里插入图片描述][2020090613542669.png_pic_center]  
***推荐文章***

*  [【C++21天养成计划】不聊学习只谈干货（Day1）][C_21_Day1]
 *  [【人生苦短，我学 Python】序言——不学点Python你就out了？][Python_Python_out]
 *  [TF2.0深度学习实战（一）：分类问题之手写数字识别][TF2.0]

[20200519132914110.jpg_pic_center]: https://img-blog.csdnimg.cn/20200519132914110.jpg#pic_center
[20200519140846763.jpg_pic_center]: https://img-blog.csdnimg.cn/20200519140846763.jpg#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dqaW5qaWU_size_16_color_FFFFFF_t_70_pic_center]: https://img-blog.csdnimg.cn/20200519151834374.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dqaW5qaWU=,size_16,color_FFFFFF,t_70#pic_center
[C_Day3]: https://blog.csdn.net/wjinjie/article/details/105396428
[20200519162413949.PNG_pic_center]: https://img-blog.csdnimg.cn/20200519162413949.PNG#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dqaW5qaWU_size_16_color_FFFFFF_t_70_pic_center 1]: https://img-blog.csdnimg.cn/20200519163857375.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dqaW5qaWU=,size_16,color_FFFFFF,t_70#pic_center
[20200519164835442.PNG_pic_center]: https://img-blog.csdnimg.cn/20200519164835442.PNG#pic_center
[20200519170323389.PNG_pic_center]: https://img-blog.csdnimg.cn/20200519170323389.PNG#pic_center
[https_blog.csdn.net_wjinjie]: https://blog.csdn.net/wjinjie
[https_ai-wx.blog.csdn.net_article_details_107509243]: https://ai-wx.blog.csdn.net/article/details/107509243
[20200519190452629.PNG_pic_center]: https://img-blog.csdnimg.cn/20200519190452629.PNG#pic_center
[C_Day3 1]: https://blog.csdn.net/wjinjie/category_9871402.html
[2020051919401694.PNG_pic_center]: https://img-blog.csdnimg.cn/2020051919401694.PNG#pic_center
[2020090613542669.png_pic_center]: https://img-blog.csdnimg.cn/2020090613542669.png#pic_center
[C_21_Day1]: https://blog.csdn.net/wjinjie/article/details/105316043
[Python_Python_out]: https://ai-wx.blog.csdn.net/article/details/110674503
[TF2.0]: https://ai-wx.blog.csdn.net/article/details/104700834