深入浅出C指针，细节之处见真章，拒绝一切无病呻吟！！！

文章目录

前言
认识指针篇
- 为什么要熟练指针？
- - 难度指数：1颗星 / 细节指数：3颗星 / 重要指数：3颗星
指针一定要在声明时初始化？
- - 难度指数：1颗星 / 细节指数：2颗星 / 重要指数：3颗星
- 你可曾见过 void 指针？
- - 难度指数：3颗星 / 细节指数：3颗星 / 重要指数：3颗星
- 指针操作与算术运算
- - 难度指数：2颗星 / 细节指数：3颗星 / 重要指数：2颗星
- 常量与指针
- - 难度指数：3颗星 / 细节指数：4颗星 / 重要指数：4颗星
C的动态内存管理
- 指针大小一定为4吗？
- - 难度指数：1颗星 / 细节指数：4颗星 / 重要指数：4颗星
- malloc函数使用的注意点
- - 难度指数：3颗星 / 细节指数：4颗星 / 重要指数：4颗星
- realloc函数知多少？
- - 难度指数：2颗星 / 细节指数：4颗星 / 重要指数：3颗星
- 使用free释放内存
- - 难度指数：3颗星 / 细节指数：5颗星 / 重要指数：5颗星
- 是否要在程序终止前释放内存？
- - 难度指数：3颗星 / 细节指数：3颗星 / 重要指数：3颗星
指针与函数
- 局部数据指针
- - 难度指数：3颗星 / 细节指数：5颗星 / 重要指数：5颗星
- 函数指针
- - 难度指数：4颗星 / 细节指数：5颗星 / 重要指数：4颗星
结构体与指针
- 链表那些绕晕人的操作！！
- - 难度指数：4颗星 / 细节指数：5颗星 / 重要指数：5颗星
- 常见链表操作
- - 难度指数：3颗星 / 细节指数：5颗星 / 重要指数：4颗星

前言

前些天写了那篇C语言的细节，大家也挺喜欢的，还上了热榜第一。之前我一天至少水一篇的时候，能上个前十我觉得都是谢天谢地了。

后来，深思之后，我就去闭关了，闭关三天出一篇，反响很好，我哥还亲自打电话跟我说：工作了六七年，这么细博客的还真少见。

挺好的，也有一些粉丝私信我说出C++的，也有一些粉丝说还是有点把握不住，其实我在写完之后会开一个话题讨论，来口头阐述并解释一下文章内容，一般在写完之后的当天晚上或第二天晚上，把握不住的小伙伴可以来听听。

C++的安排上了，但是指针我想先安排一下。

前面写过一篇指针的，反响还不错，但是我个人感觉还是欠缺火候。于是，我又闭关三天，拿出这一篇来。

认识指针篇

为什么要熟练指针？

难度指数：1颗星 / 细节指数：3颗星 / 重要指数：3颗星

指针有多重用途，碧如说：
1、支持动态内存分配
2、提供用指针传递数据结构的能力而不会带来庞大的开销
3、保护作为参数传递给函数的数据
4、写出快速高效的代码

如果不清楚这些优势的话，那么很容易就被指针的“高难度”而劝退了。

我曾经听过一个笑话，说是有超过七成的人支持高考取消数学。
为什么呢？因为数学刷掉的就是这七成的人。

我还听过一个事情，叫做指针是非常难学的，非常危险的东西，小白们前往不要碰。
不知道这会不会也是一个笑话。

为什么要谈指针色变呢？

指针一定要在声明时初始化？

难度指数：1颗星 / 细节指数：2颗星 / 重要指数：3颗星

无稽之谈。我也不知道为什么有的人会这么说，是不是从某本书上看来的啊。

星号将变量声明为指针，星号其实是一个重载符号，因为它也用在乘法和解引指针上。

#include<iostream>
using namespace std;int main() {int* p; //这里这个星号是声明指针int a = 10;p = &a;cout << *p << endl;    //这里这个星号就是解引指针
}

到底行不行，实测一下不就知道了吗？

指向未初始化内存的指针，会直接报错，这种事情我想在座的各位都遇到过吧。

你可曾见过 void 指针？

难度指数：3颗星 / 细节指数：3颗星 / 重要指数：3颗星

在做通用链表的时候，用void指针就比较常见了。其实不止是通用链表，很多地方都会用到void指针的。

void指针是通用指针，可以用来存放任何数据类型的引用，任何指针都可以被赋给void指针，也可以被转换回原来的类型。

使用void指针的时候要小心，如果把任意指针转换为void指针，那就没什么能阻止你再把它转换成不同的指针类型了。

指针操作与算术运算

难度指数：2颗星 / 细节指数：3颗星 / 重要指数：2颗星

给指针加减整数时，其实就是指针向前后移动了，移动的地址位为：指针类型大小*整数。
看一下数据类型长度：

来一波演示就明白了：


/*以int指针做实验*/#include<iostream>
using namespace std;int main() {int* p;int a = 10;p = &a;cout << p << endl;cout << p+1 << endl;cout << p+2 << endl;cout << p+3 << endl;
}

004FFD34
004FFD38
004FFD3C
004FFD40


/*以char指针做实验*/#include<iostream>
using namespace std;int main() {char* p;char a = 10;p = &a;printf("%p\n", p);printf("%p\n", p+1);printf("%p\n", p+2);printf("%p\n", p+3);
}

00B5FA2B
00B5FA2C
00B5FA2D
00B5FA2E

数据说话

对于void指针呢？有的编译器允许给void指针做算术运算，有的不允许，所以要谨慎。

常量与指针

难度指数：3颗星 / 细节指数：4颗星 / 重要指数：4颗星

分一下啊：

常量\指针	常量	普通
常量	1、指向常量的常量指针	2、指向常量的普通指针
普通	3、指向非常量数据的常量指针	4、指向非常量的普通指针

指向常量的普通指针：

int main() {const int a = 10;int b = 0;const int* p = &a; //这是一个指向整数常量的指针、//int* pp = &a;    //无法将一个const int* 对象赋值给int*p = &b; //将指针指向另一个对象//*p = 100;    //表达式必须有一个可以修改的左值//我们可以用p来解引用，但是不能用p来修改它，即使它是一个普通变量//因为它认为自己指向的是一个整数常量，服不服？！int* pp = &b;*pp = 100;}

总结：

p可以被修改为指向不同的常量
p可以被修改为指向不同的变量
可以解引用以读取数据
不能解引从而修改它指向的数据

指向变量的常量指针：

#include<iostream>
using namespace std;int main() {int a = 10;int b = 0;int* const p = &a;  //这是一个指向变量的常量指针、//p = &b;  //将指针指向另一个对象//表达式必须有一个可以修改的左值*p = 100; //可以对p进行解引用以修改所指向地址内的内容
}

总结：

p被初始化为指向变量的常量指针
p不能指向其它对象
p指向的数据可以被修改

C的动态内存管理

指针大小一定为4吗？

难度指数：1颗星 / 细节指数：4颗星 / 重要指数：4颗星

对于常用4个字节地址的计算机系统，指针的大小为4个字节，其他系统中指针的大小不一定为4个字节。

为什么要说这个呢？举个简单的栗子吧：

struct text* a;  //这是一个结构体对象
···//现在，需要初始化一块空间，将结构体内容写入进行网络传输//方案一：
char* str_a = new(sizeof(a));      //方案二：
char* str_a = new(sizeof(struct text));//站在一个小白的角度，这两个方案你们怎么选？

作为一个小白，我根本不选的，感觉这俩不是没什么差别吗？
那当然选方案一了，能少写几个代码。

然后，暴雷了，怎么写都只能传输四个字符，一度还以为是我的队友那边客户端写的有问题。
后来排查下来，是我这里的问题。

还好出问题了，不然我到现在没记性。

malloc函数使用的注意点

难度指数：3颗星 / 细节指数：4颗星 / 重要指数：4颗星

C的动态内存分配函数主要有：

malloc：从堆上分配内存
calloc：从堆上分配内存并清零
realloc：在之前分配内存的基础上，将内存重新分配为更大或更小的部分
free：将内存块返回堆

动态内存从堆上分配，系统不保证内存分配的连续性，不过，内存会根据指针的数据类型对齐，比如说，四个字节的整数会被分配在能被4整除的地址边界上，堆管理器返回的地址是最低字节的地址。

1、malloc的参数类型为size_t，如果传入参数为负数，是要出事儿的。
2、如果传入参数为0，要么返回NULL，要么返回一个0区的指针。
3、确定所分配的内存数。回忆一下上面那一点。

那如果是要分配10个double呢？这样写：

double *d = (double*)malloc(10*sizeof(double));

其他数据类型以此类推即可，其实基本数据类型有多大大家都清楚，就怕那些非基本数据类型的，所以统一这样写就好啦，还能在代码移植的过程中更安全。

4、malloc函数的使用流程：

double *d = (double*)malloc(10*sizeof(double));
if(d!=NULL){   //如果分配空间成功memset(d,0,10);       //清空所分配的空间···
}

本来还要讲一下calloc的，但是为什么calloc办事儿比malloc彻底，用的却没malloc多呢？
那肯定是有它的道理的。

速度就是硬道理！！！

realloc函数知多少？

难度指数：2颗星 / 细节指数：4颗星 / 重要指数：3颗星

看一下函数原型：

void* realloc(void*ptr,size_t size);

第一个参数	第二个参数	行为
空	0
非空	0	原内存被释放
非空	>原内存	利用当前的块分配更小的块，多余内存被回收
非空	<原内存	如果可以，紧贴着当前内存后面再分配；如果不行，再其他位置再分配；如果没有空间足够，这返回NULL，并报错

使用free释放内存

难度指数：3颗星 / 细节指数：5颗星 / 重要指数：5颗星

首先，我就不说啥，有多少人在使用完指针之后记得释放的可以在评论区跟我说一声儿，我敬你是条汉子。

好，这是第一个细节。

已释放的指针依然可能造成问题。如果我们试图解引一个已释放的指针，其后果是未可知的，所以有的时候我们显式的给指针赋值为NULL，表示该指针无效，此后再使用这种指针就会造成运行异常。

在调用free之后，要记得给指针附NULL，
此外，除了初始化的情况，都不能将NULL赋值给指针。

重复释放问题：
重复释放是指两次释放同一个内存。
重复释放也是一个问题，两个指针引用同一个地址称为别名（想一下链表）。

由于free函数存在的这些问题，我们可以创建一个自己的free函数，我来打个样儿：

void My_Free(void **p){//这是一个我们自己的free函数//1、防止指针被回收但是指向的内存没有释放//2、防止重复释放指针if(p != NULL && *p != NULL){ free(*p);*p = NULL;}
}

是否要在程序终止前释放内存？

难度指数：3颗星 / 细节指数：3颗星 / 重要指数：3颗星

这个其实就没那么好说了，要取决于具体的应用程序。

虽然说，在使用完之后要记得释放内存，但是程序都关闭了，确保程序终止之前释放所有的内存，有可能得不偿失：

可能很耗时，释放复杂结构也比较麻烦
可能增加应用程序的大小
增加更多编程错误的概率

看情况吧。

指针与函数

使用函数时，有两种情况指针很有用，首先是将指针传递给函数，这时函数可以修改指针所引用的数据，也可以更高效的传递大块信息。

另一种情况就是声明函数指针，其实函数表示法就是指针表示法（以前老师有跟我们说过）。

局部数据指针

难度指数：3颗星 / 细节指数：5颗星 / 重要指数：5颗星

什么是局部数据指针，这个是一个比较危险的坑，有时候代码写着写着就掉进去了。

不讲别人，就讲我，我之前写过这样一个函数：

char* forget(){//函数名字忘了，参数啥的也都忘了，核心是记住了char* res = new char[100];sprintf(···);return res;
}

然后在外面开始接收这个返回值。
但是很纳闷儿，有时候可以接受到，有时候接收不到，反馈是：客户端那边有时候有数据，有时候没数据。

于是我可怜的组员又出来背锅了：“是不是你接收的地方写出问题了啊？不是吗？那解压包呢？是不是包拆错了？”

好吧，确认了不全是他的问题。

“是不是我们协议没对好？前天改协议之后我发群里了，我们的协议是统一的吗？”
又开始对协议。

好吧，可能是我的错。
于是开始排查。
好吧，原来全是我的问题。。。

那么，什么叫“局部函数指针”？

顾名思义，就是在函数里面声明并分配内存的指针。
这种指针以及它分配到的内存，作用域属于这个函数，一旦函数结束，它理论上是没有了。但是，回收需要时间，所以就会造成：有时候收的到数据，有时候收不到数据。

敲黑板：“作用域”三个字圈起来要考！！！

函数指针

难度指数：4颗星 / 细节指数：5颗星 / 重要指数：4颗星

函数指针完成任务的流程是这样的：

获取函数的地址
声明一个函数指针
使用函数指针来调用函数
获取函数地址

获取函数地址那是比较简单的事，如果说 void Hanshu();这是一个函数，那么它的地址就是 Hanshu。
如果函数Hanshubaba();要调用这个函数，是这样的：Hanshubaba(Hanshu);
切记不能写成：Hanshubaba(Hanshu());

假设现在有这么一个函数：int test3(void *arg); //这个arg参数，回调函数里面用，要解释有点长。
现在要将之改成函数指针形式：int （*test3）(void *arg);

首先，将test3更换成（*test3），因此，（*test3）也是函数，那么test3就是函数指针。
为声明优先级，需要将 *test3 括号起来。

如果你非要我说函数指针存在的意义，那我也真不好给你扯个所以然出来，那我就，举几个用得到的地方吧：

自定义排序/搜索不同的模式（如策略，观察者）回调

本来这里应该有一个“字符串和指针”的部分的，但是应朋友们的需求，下一篇专门整理字符串，所以这一部分就移到下一篇啦。

结构体与指针

链表那些绕晕人的操作！！

难度指数：4颗星 / 细节指数：5颗星 / 重要指数：5颗星

链表在C语言的数据结构中的地位可不低。后面很多的数据结构，特别是树，都是基于链表发展的。
所以学好链表，后面的结构才有看的必要。

我们先看一下链表的节点数据结构吧：

//节点描述结构体
typedef struct point
{void *pData;               //指向数据域struct point *next;          //指向下一个节点
} POINT_T;

注意区分，链表是会有两个“结构”的，一个是数据节点，一个是搭载数据节点的链表节点。
可以想象一下动车，车厢和人，是分离的。
不要忽视这个简单的概念，这是学完链表一段时间之后还能不能搞明白链表的重中之重！！！

上面这个，就是“车厢”，里面的“pData”，可以视为“人”。

拿个“人”的栗子看看：

//节点数据结构体
typedef struct test
{   char name[12];      //名字char pwd[8];        //密码int number;         //编号int flag;           //区分管理员和用户  //  0 超级管理员 1 管理员  2 普通用户 3 屏蔽用户int money;          //仅用户有存款，初始500
} TEST_T;

既然它是void*，那么就意味着它可以是任意的数据结构，也可以是基本数据结构，如int。

每一节“车身”，不经过操作和变换的时候，它的地址都是固定的，它的前后节“车厢”地址也是固定的。

我们来看几个基本操作，注意区分：

(伪代码)
PData* head;    //链表的头
PData* tempA = head;   //临时节点，但是它现在也是链表的头了
PData* tempB = head;   //临时节点，但是它现在也是链表的头了

现在，head、tempA、tempB，不是同一个指针，但是指向了同一个地址。
这三个指针，对于当前地址上的一切，有着共同的，一票决定权。会有点绕吧。

现在我们来再执行几个操作看看：

tempA = tempA->next;
//将tempA指针指向下一个节点，失去了对原地址的决定权，但是保留了对原地址的下一个地址的绝对权力。另外两个指针并不受影响
tempB->next = NULL;
//好家伙，tempB指针将当前地址的下一个指针域置空了，由于tempA已经走了，所以不受影响，但是head指针指向的部分同时被清空了

看到没，这既是链表中最让人容易绕晕的操作之一了。

我们回到前面，就当这波操作没有发生过，再看一波操作：

head->next = tempA;
//将tempA接到了head的下面，原本A后面的内容就没有掉了
//但是，tempA也受到了影响，这句话等同于：
head->next = head;
//陷入了死循环

好，再回到原点，我们再看一波操作：

head->val = 0;
//将head指针指向的值域的值置0，则tempA、tempB所指向值域的值读出来也是0了。

其实链表绕来绕去无非这几点，但是也就这几点，就够绕傻人了。

解链表题，最好的办法就是最土的办法，先在纸上吧整个操作流程画明白了再动手！！！

常见链表操作

难度指数：3颗星 / 细节指数：5颗星 / 重要指数：4颗星

//创建结点
POINT_T * creat(void *data )    //创建一个属于结构体point的函数，
//传入结构体test的指针便可以用以操作test变量，
{                               //并返回一个point的指针用以操作point函数POINT_T *p=NULL;p=(POINT_T *)malloc(sizeof(POINT_T));if(p==NULL){printf("申请内存失败");exit(-1);}memset(p,0,sizeof(POINT_T));p->pData=data;p->next=NULL; //处理干净身后事return p;
}//新增节点
void add(POINT_T * the_head,void *data )                //这里的data不会和上面那个冲突吗？
{POINT_T * pNode=the_head;                         //把头留下POINT_T *ls=creat(data);//后面再接上一个while (pNode->next != NULL)                         //遍历链表，找到最后一个节点{pNode=pNode->next;}pNode->next=ls;           //ls 临时
}//删除节点
void del(POINT_T * the_head, int index)
{POINT_T *pFree=NULL;                  //用来删除POINT_T *pNode=the_head;int flag=0;while (pNode->next!=NULL){if(flag==index-1){pFree=pNode->next;             //再指向数据域就爆了pNode->next=pNode->next->next; //这里要无缝衔接free(pFree->pData);             //先释放数据free(pFree);                 //释放指针break;}pNode=pNode->next;flag++;    }
}//计算节点数
int Count(POINT_T * the_head)
{int count=0;POINT_T *pNode1=the_head;while (pNode1->next!=NULL){pNode1=pNode1->next;count++;       }   return count;
}//查找固定节点数据
POINT_T * find(POINT_T *the_head,int index)
{int f=0;POINT_T *pNode=NULL;int count=0;pNode=the_head;count=Count(the_head);if(count<index)   printf("find nothing");while(pNode->next!=NULL){if(index==f)return pNode;pNode=pNode->next;f++;       }
}

精品专栏打造计划！！！