庆祝鱼c五周年，发个帖子 ，浅谈c语言指针的一点归纳

漠水

看懂这个，指针应该就差不多搞定了吧。

一个变量分为两个方面存储变量数据的地址和地址里的值。
定义一个变量int a ；a 在计算机中本身被翻译的就是一个地址；
如                   变量a       地址 1000 地址里的值是0023
如int *b;       b=&a;       地址 1008 地址里的值是1000

指针本身就是一个变量，存储就是指向变量的地址      
      回调函数分为有参函数和无参函数，定义时的形参和调用时的实际参数是两个不同的变量
如同 int a;         形参                     地址     1000          存储的数值   1010
       int b;         实参                     地址     2000          存储的数值   1010
       a=b=10;   这就是函数参数的传递过程
而在函数调用时我们要改变实参的值则需要应用到指针，值传递时我们函数调用时在修改形参（1000）的值，
修改之后释放与实参（2000）无关；
而在函数中我们调用指针则如下
如同 int *a;         形参                     地址     1000          存储的数值   1008
       int *b;         实参                     地址     2000          存储的数值   1008
       int  c         b=&c                    地址     1008           存储的数值  2000

我们需要改变的都是地址1008里的值   

在函数调用中，我们常见调用结构体的类型有返回值和无返回值的，一般书本上
单链表中返回头指针head  ，利用回调函数中定义变量node* head，return head；
主函数中重新定义node *head；head=creat();来实现单链表的建立   

而二叉树无返回值，则需要用指针参数，而又因为二叉树中的申请结构体的需要调用到参数，
假定二叉树中指针参数： 实参地址1000    形参地址2000
形参指针变量申请结构体的话因为地址不同，结构体的也会改变
实参申请地址      1008——1020       形参申请地址2008——2020
所以我们需要用到二重指针来解决这个问题      
用到二重指针我们需要确定指针地址（形参实参地址不同）来确定利用指针申请的结构体的首地址
以下几个例子说明

1. #include<stdio.h>
   
2. 
   
3. //用int型变量改变地址
   
4. void f1(int a)
   
5. {
   
6. a=a+10;
   
7. }
   
8. //令指针所指向的地址中的值改变
   
9. void f2(int *a)
   
10. {
    
11. *a=20;
    
12. 
    
13. }
    
14. 
    
15. void main()
    
16. {
    
17. int k=10;
    
18. int *a;
    
19. a=&k;
    
20. f1(k);
    
21. printf("f1中a的值%d\n",k);        //没有变化，等于10
    
22. f2(a);
    
23. printf("f1中a的值%d\n",k);        //有变化，等于20
    
24. 
    
25. }

复制代码

1. #include<stdio.h>
   
2. #include<stdlib.h>
   
3. #include<conio.h>
   
4. 
   
5. typedef struct node
   
6. {
   
7. int a;
   
8. }node;
   
9. 
   
10. //令指针所指向的地址中的值改变
    
11. void f2(node *p)
    
12. {
    
13. p->a=20;
    
14. }
    
15. 
    
16. void main()
    
17. {
    
18. node p;                        //声明一个node结构变量p           自动分配了一个长度为node结构体的地址
    
19. node *q;                //声明一个指向node结构变量的指针，若是指针需要用q=(node *)malloc(node)申请;
    
20. p.a=10;                        
    
21. printf("%d\n",p.a);   //查看p中的值
    
22. q=&p;                        //令结构体指针q指向p
    
23. f2(q);                        
    
24. printf("%d\n",p.a);   //查看是否改变p中的值
    
25. 
    
26. }

复制代码

1. #include<stdio.h>
   
2. #include<stdlib.h>
   
3. #include<conio.h>
   
4. 
   
5. 
   
6. void f3(int *a)
   
7. {
   
8. printf("f3函数中的存储的数值为%d\n",a);
   
9. printf("f3函数中的地址为%d\n",&a);
   
10. }
    
11. 
    
12. void main()
    
13. {
    
14. int *a;
    
15. printf("主函数中的存储的数值为%d\n",a);
    
16. printf("主函数中的地址为%d\n",&a);
    
17. f3(a);
    
18. 
    
19. }

复制代码

上例说明形参实参存储数值相同，地址不同

二叉树中为何要调用二重指针：
以下2个例子对比说明，指针申请位置不同p=(node *)malloc(sizeof(node)); 其余相同
一个申请在主函数，一个申请在回调函数中，结果回调函数中的形参申请的结构体因为地址与实参无关所以报错，
而在主函数中的结构体则不会。

1. #include<stdio.h>
   
2. #include<stdlib.h>
   
3. #include<conio.h>
   
4. 
   
5. typedef struct node
   
6. {
   
7. int a;
   
8. 
   
9. }node;
   
10. 
    
11. 
    
12. //令指针所指向的地址中的值改变
    
13. void f2(node *p)
    
14. {
    
15. printf("f2函数中指针p的地址为%d\n",&p);   
    
16. p=(node *)malloc(sizeof(node));
    
17. p->a=20;
    
18. }
    
19. 
    
20. void main()
    
21. {
    
22. node *p;
    
23. printf("主函数中指针p的地址为%d\n",&p);
    
24. f2(p);               
    
25. getch();
    
26. printf("%d\n",p->a);   //查看是否改变p中的值
    
27. }

复制代码

1. #include<stdio.h>
   
2. #include<stdlib.h>
   
3. #include<conio.h>
   
4. 
   
5. typedef struct node
   
6. {
   
7. int a;
   
8. 
   
9. }node;
   
10. 
    
11. 
    
12. 
    
13. //令指针所指向的地址中的值改变
    
14. void f2(node *p)
    
15. {
    
16. printf("f2函数中指针p的地址为%d\n",&p);
    
17. p=(node *)malloc(sizeof(node));
    
18. p->a=20;
    
19. }
    
20. 
    
21. void main()
    
22. {
    
23. node *p;
    
24. printf("主函数中指针p的地址为%d\n",&p);
    
25. p=(node *)malloc(sizeof(node));
    
26. f2(p);               
    
27. getch();
    
28. printf("p->a的值为%d\n",p->a);   //查看是否改变p中的值
    
29. }

复制代码

漠水

@拈花小仙   看来路漫漫其修远，越写越感觉好多好多要学的 :lol: