后台-插件-广告管理-内容页广告位一(手机)

您现在的位置是:首页 >  企业信息化 > 操作系统 > 其他其他

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

2021-06-07 21:02:21其他人已围观

简介我曾经听过一个笑话,说是有超过七成的人支持高考取消数学。为什么呢?因为数学刷掉的就是这七成的人。我还听过一个事情,叫做指针是非常难学的,非常危险的东西,小白们前往不要碰。不知道这会不会也是一个笑话。为什么要谈指针色变呢?前面写过一篇指针的,反响还不错,但是我个人感觉还是欠缺火候。于是,我又闭关三天,拿出这一篇来。慢慢看,把握不住的地方私信我。

在这里插入图片描述

文章目录

    • 前言
    • 认识指针篇
      • 为什么要熟练指针?
        • 难度指数: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、确定所分配的内存数。回忆一下上面那一点。

那如果是要分配5个double呢?这样写:

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

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

4、malloc函数的使用流程:

double *d = (double*)malloc(10*sizeof(malloc));
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++;		
	}
}

在这里插入图片描述


精品专栏打造计划!!!

文章来源:https://blog.csdn.net/qq_43762191/article/details/117516040

Tags:指针 malloc 内存管理 内存泄漏 c 

很赞哦! ()

后台-插件-广告管理-内容页广告位二(手机)

相关文章

后台-插件-广告管理-内容页广告位三(手机)

随机图文

后台-插件-广告管理-内容页广告位四(手机)

文章评论

留言与评论(共有 0 条评论)
   
验证码:

本栏推荐

站点信息

  • 文章统计60324篇文章
  • 浏览统计4607次浏览
  • 评论统计1个评论
  • 标签管理标签云
  • 统计数据:统计代码
  • 微信公众号:扫描二维码,关注我们