(图解)解析链表中的LinkList *L, LinkList L和LinkList &L,结构体指针和指向结构体指针的指针的区别

       在计算机中,程序运行时,数据要被存储到内存中,而每个内存都有一个内存地址,如下图:

         内存地址为1001存储着数值1,内存地址为1002存储着数值2.(这里内存地址只是为了方便而这样写,计算机的内存地址表示不一定这样)

        然后咱们看链表的存储结构:

typedef struct Node
{
	int data;
	struct Node* next;
}LNode, *LinkList;

// LNode为结构体,LinkList为结构体指针

其中LNode表示结构体,LinkList表示结构体指针。

        再看传入结构体指针LinkList L 的 DontChange_point()函数:

void DontChange_point(LinkList L)
{
	printf("函数DontChange_point中L指向的地址为:%pn", L);
	printf("L指向的data为:%dn", L->data);
	printf("存储L的地址为:%pn", &L);
	L = (LinkList)malloc(sizeof(LNode));
	L->data = 2;
	L->next = NULL;
	printf("现在L指向的地址为:%pn", L);
	printf("L指向的data为:%dn", L->data);
	printf("存储L的地址为:%pn", &L);
	return;
}

        再看传入指向结构体指针的指针LinkList *L(二级指针)的Change_point()函数:

void Change_point(LinkList* L)
{
	printf("L指向的地址为:%pn", L);
	printf("存储L的地址为:%pn", &L);
	*L = (LinkList)malloc(sizeof(LNode));
	(*L)->data = 2;
	(*L)->next = NULL;
	return;
}

那传入结构体的指针和指向结构体指针的指针区别呢?

先看下图:

        首先咱们将结构体存储在1(内存地址为1001)处,而指向结构体的指针 L 保存的便是结构体的地址1001(即解引此地址(*L)可以得到结构体),而这个结构体指针需要内存来存储它,故其也有一个地址(即内存地址2001保存了L,L保存了地址2001上的数据(即1001),解引此地址(2001)可以得到内存地址1001,再解引1001便可得到结构体,双重解引),即内存地址2001保存着内存地址1001(也就是L),而内存地址1001保存着结构体。

        可能这有点迷糊,咱们可以这样理解就是咱们可以把内存地址想成一个盒子,将结构体想成是一件物品,编号为1001(相当于内存地址1001)的盒子(即L)装着这个物品(即结构体),如果我们将这个盒子打开就可以得到这个物品(结构体),其实这个过程相当于解引结构体指针(指针解引),然后咱们再把编号为2001的盒子把编号为1001的盒子(即L)装起来,咱们是不是要打开两次盒子(一次为2001,一次为1001)才能得到这个物品(相当于双重解引)。


        传入结构体指针,相当于把内存地址1001赋给了DontChange_point函数中的 L(传址),但 L不一定需要指向这块内存地址(1001),其也可以指向别的内存地址,当其指向别的地址,然后再进行操作,会不会影响我们之前传入的内存1001里的结构体呢?如:

void DontChange_point(LinkList L)
{
	printf("函数DontChange_point中L指向的地址为:%pn", L);
	printf("L指向的data为:%dn", L->data);
	printf("存储L的地址为:%pn", &L);
	L = (LinkList)malloc(sizeof(LNode));
	L->data = 2;
	L->next = NULL;
	printf("现在L指向的地址为:%pn", L);
	printf("L指向的data为:%dn", L->data);
	printf("存储L的地址为:%pn", &L);
	return;
}

        这个指针L指向了用malloc()函数分配的内存,并且进行了修改L指向的结构体的操作,但它会影响我们之前传入的地址所指向的结构体吗?咱们用程序说话:

int main(void)
{
	LinkList L;
	L = (LinkList)malloc(sizeof(LNode));
	L->data = 1;
	L->next = NULL;
	printf("L指向的地址为:%pn", L);
	printf("L指向的data为:%dn", L->data);
    printf("存储L的地址为:%pn", &L);
	DontChange_point(L);
	printf("现在main()函数中L指向的data为:%dn", L->data);
    return 0;
}

程序输出:

      在main()函数结构体指针L指向的地址和刚传入DontChange_point()函数的地址L是一致的,但保存这个结构体指针的地址确是不一致的,说明是两个变量(main函数里的L和DontChange_point()函数的L)是不一样的。故后面改变DontChange_point()函数的L的指向,影响不到main()函数里的L,故在DontChange_point()函数的L对结构体的操作影响不了main()函数中L指向的结构体,而事实也证明如此,两次输出都是1,并没有因为DontChange_point()函数的L的操作而改变为结构体的data由1变为2.

如下图:

刚开始,DontChange_point()函数的L的指向


 后面DontChange_point()函数的L经过malloc()函数进行分配:


        而传入指向结构体指针的指针,相当于把main()函数中保存L的地址给传进去了,然后再这块地址上做的操作会不会影响外面main()函数中的L呢?咱们直接上程序:

void Change_point(LinkList* L)
{
	printf("L指向的地址为:%pn", L);
	printf("存储L的地址为:%pn", &L);
	*L = (LinkList)malloc(sizeof(LNode));
	(*L)->data = 2;
	(*L)->next = NULL;
	return;
}
int main(void)
{
	LinkList L;
	L = (LinkList)malloc(sizeof(LNode));
	L->data = 1;
	L->next = NULL;
	printf("L指向的地址为:%pn", L);
	printf("L指向的data为:%dn", L->data);
	printf("存储L的地址为:%pn", &L);
	Change_point(&L); // 获取保存L的地址
	printf("现在main()函数中L指向的data为:%dn", L->data);
	return 0;
}

         咱们在Change_point()函数中,将传入保存mian()函数中L的地址赋给了Change_point()函数L,再对这块内存要保存的数据进行修改(修改这块内存要保存的地址,利用malloc()函数进行分配),即这块内存上的数据要改变,而main()函数的L指向的是这块内存的数据,故其也跟着改变,那事实是不是这样呢,咱们看程序输出。

程序输出:

程序输出说明,在Change_point()函数的操作影响到了外面main()函数的L,并且Change_point()函数中的L和外面main()函数保存结构体指针L的地址是一致的,说明对Change_point()函数中L的地址上所改变的内容会影响到main()函数的L(因为main()函数中的L是保存这块内存的数据信息)。程序输出也证明了事实如此,在没执行函数前,L->data = 1,指行函数后L->data = 2。

 如下图:

刚开始:(下面的L均代表的是main()函数中的L)

 利用malloc()函数进行操作后:


 LinkList &L是C++的指针引用,其相当于LinkList *L,分析也类似分析LinkList *L,这里就不介绍了。

总的来说:

        在参数为结构体指针的函数里,你可以对这个结构体指针所指向的内容进行修改,但函数外的结构体指针一直会指向这块内存(不会因为函数参数所指向别处,而跟着指向别处)。也就是说如果函数的参数(结构体指针)没有改变指向(指向别处),函数对指针所指向的内容进行修改,函数外的结构体指针(传入函数的指针)所指向的内容也会改变,但若函数的参数改变指向(即不指向传入指针指向的内存地址,其修改的内容不会影响到函数外结构体指针所指向的内容,即函数外结构体指针之前指向的内容不会改变)。参数为结构体指针的函数,不会修改函数外结构体指针所指向的内存地址,但可以修改结构体指针指向的结构体。

        在参数为指向结构体指针的指针,会影响到函数外的结构体指针所指向的地址,进而影响结构体指针指向的结构体。

        所以当我们的函数不需要修改函数外结构体指针所指向的内存地址,同时又想修改结构体指针所指向的结构体,便可以将函数的参数设为结构体指针。但如果我们的函数想修改函数外结构体指针所指向的内存地址时,我们便要传入指向结构体指针的指针,不可传入结构体指针。


        内容到此结束,谢谢大家的阅读!!

测试程序:

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

typedef struct Node
{
	int data;
	struct Node* next;
}LNode, *LinkList;

void Change_point(LinkList* p);
void DontChange_point(LinkList p);

int main(void)
{
	LinkList L;
	L = (LinkList)malloc(sizeof(LNode));
	L->data = 1;
	L->next = NULL;
	printf("L指向的地址为:%pn", L);
	printf("L指向的data为:%dn", L->data);
	printf("存储L的地址为:%pn", &L);
	DontChange_point(L);
	printf("现在main()函数中L指向的data为:%dn", L->data);
	Change_point(&L);
	printf("现在main()函数中L指向的data为:%dn", L->data);
	return 0;
}

void Change_point(LinkList* L)
{
	printf("L指向的地址为:%pn", L);
	printf("存储L的地址为:%pn", &L);
	*L = (LinkList)malloc(sizeof(LNode));
	(*L)->data = 2;
	(*L)->next = NULL;
	return;
}

void DontChange_point(LinkList L)
{
	printf("函数DontChange_point中L(没改变其指向)指向的地址为:%pn", L);
	printf("L指向的data为:%dn", L->data);
	printf("存储L的地址为:%pn", &L);
	L = (LinkList)malloc(sizeof(LNode));
	L->data = 2;
	L->next = NULL;
	printf("现在L(改变了其指向)指向的地址为:%pn", L);
	printf("L指向的data为:%dn", L->data);
	printf("存储L的地址为:%pn", &L);
	return;
}

本图文内容来源于网友网络收集整理提供,作为学习参考使用,版权属于原作者。
THE END
分享
二维码

)">
< <上一篇
下一篇>>