[已解决]求助大佬，指针地址问题

wht666

当我调用addx函数时，传指针，也就是一级指针时，在addx函数中  p  指针确实保存了malloc申请空间返回的地址值，但是为什么在主函数中却还是  NULL 0，函数调用中地址传递不是会改变原来这个变量的值吗，又不是值传递。

但是，当我调用addy函数时，传的是指针的地址，也就是一个二级指针，然后在调用的  函数addy  和  主函数  中，p这个指针和&p这个指针地址（二级指针）都有；和刚刚第一种情况完全不一样。想不懂是为啥？？？

我一直的理解是地址传递在主函数中也是改变的，因为是在内存中改变了，就像第二个函数addy那样，地址传递不是像值传递那样，复制一份数据到另外一个函数，而是复制地址，然后对地址操作。
我的问题是：调用函数为什么改变不了一级指针的值，也就是地址。而二级指针却可以！！！
求大佬们解答一下，谢谢！！！

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. typedef struct std
   
5. {
   
6.     char date;
   
7.     struct std *p;
   
8. 
   
9. }std;
   
10. void addx(std *p)
    
11. {
    
12.     p=(std *)malloc(sizeof(std));
    
13.     printf("addx函数中：%p\n",p);
    
14. }
    
15. void addy(std **p)
    
16. {
    
17.     *p=(std *)malloc(sizeof(std));
    
18. 
    
19.     printf("(指针本身) addy函数中*p：%p\n\n",*p);
    
20.     printf("(指针地址)addy函数中的p：%p\n\n",p);
    
21. 
    
22. }
    
23. 
    
24. 
    
25. int main(void)
    
26. {
    
27.     std *p=NULL;
    
28.     //一级指针
    
29.     addx(p);
    
30.     printf(" 主函数中：%p\n",p);
    
31.     free(p);
    
32.     printf("==========\n");
    
33.     //&p，传指针的地址，相当于二级指针
    
34.     addy(&p);
    
35.     printf("(指针本身)    主函数中p：%p\n\n",p);
    
36.     printf("(指针地址)   主函数中&p：%p\n\n",&p);
    
37.     free(p);
    
38.     printf("==========\n");
    
39. 
    
40.     return 0;
    
41. }
    

复制代码

最佳答案

月排行榜 / 总排行榜

Cool_Breeze

2020-5-5 15:06:25

void addx(std *p) 相当于 void addx （int a)
void addy(std **p) 相当于 void addy (int &a)
明白不
    addx(p);//这里不是传入的指针，是一个指针的值；
    addy(&p);//取指针变量的地址（显式地传递实参的地址）（这样才能更改它的事实参数）；

跳转到最佳答案楼层

Cool_Breeze

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. typedef struct std
   
5. {
   
6.     char date;
   
7.     struct std *p;
   
8. 
   
9. }std;
   
10. std* addx(void)
    
11. {
    
12.     std* p=(std *)malloc(sizeof(std));
    
13.     printf("addx函数中：%p\n",p);
    
14.     return p;
    
15. }
    
16. void addy(std **p)
    
17. {
    
18.     *p=(std *)malloc(sizeof(std));
    
19. 
    
20.     printf("(指针本身) addy函数中*p：%p\n\n",*p);
    
21.     printf("(指针地址)addy函数中的p：%p\n\n",p);
    
22. 
    
23. }
    
24. 
    
25. 
    
26. int main(void)
    
27. {
    
28.     std *p=NULL;
    
29.     //一级指针
    
30.     p=addx();
    
31.     printf(" 主函数中：%p\n",p);
    
32.     free(p);
    
33.     printf("==========\n");
    
34.     //&p，传指针的地址，相当于二级指针
    
35.     addy(&p);
    
36.     printf("(指针本身)    主函数中p：%p\n\n",p);
    
37.     printf("(指针地址)   主函数中&p：%p\n\n",&p);
    
38.     free(p);
    
39.     printf("==========\n");
    
40. 
    
41.     return 0;
    
42. }
    

复制代码

1. addx函数中：00000000002DFC80
   
2. 主函数中：00000000002DFC80
   
3. ==========
   
4. (指针本身) addy函数中*p：00000000002DFC80
   
5. 
   
6. (指针地址)addy函数中的p：000000000022FE48
   
7. 
   
8. (指针本身)    主函数中p：00000000002DFC80
   
9. 
   
10. (指针地址)   主函数中&p：000000000022FE48
    
11. 
    
12. ==========
    
13. 
    
14. --------------------------------
    
15. Process exited after 0.007449 seconds with return value 0
    
16. 请按任意键继续. . .
    

复制代码

wht666

Cool_Breeze 发表于 2020-5-5 14:35

没看懂，大佬可不可以解释一下

wht666

Cool_Breeze 发表于 2020-5-5 14:35

还有就是，我想要理解的是，函数参数传地址，然后改变这个地址的问题。
你这个都变了个意思了，都是在其他函数得到一个地址然后返回。

Cool_Breeze

把指针设置为全局变量就好了！

wht666

Cool_Breeze 发表于 2020-5-5 14:51
把指针设置为全局变量就好了！

我试了，不行

Cool_Breeze

wht666 发表于 2020-5-5 14:54
我试了，不行

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. typedef struct std
   
5. {
   
6.     char date;
   
7.     struct std *p;
   
8. 
   
9. }std;
   
10. 
    
11. std *p=NULL;//在这里
    
12. 
    
13. void addx(void)
    
14. {
    
15.     p=(std *)malloc(sizeof(std));
    
16.     printf("addx函数中：%p\n",p);
    
17. }
    
18. void addy(std **p)
    
19. {
    
20.     *p=(std *)malloc(sizeof(std));
    
21. 
    
22.     printf("(指针本身) addy函数中*p：%p\n\n",*p);
    
23.     printf("(指针地址)addy函数中的p：%p\n\n",p);
    
24. 
    
25. }
    
26. 
    
27. 
    
28. int main(void)
    
29. {
    
30.     //std *p=NULL;
    
31.     //一级指针
    
32.     addx();
    
33.     printf(" 主函数中：%p\n",p);
    
34.     free(p);
    
35.     printf("==========\n");
    
36.     //&p，传指针的地址，相当于二级指针
    
37.     addy(&p);
    
38.     printf("(指针本身)    主函数中p：%p\n\n",p);
    
39.     printf("(指针地址)   主函数中&p：%p\n\n",&p);
    
40.     free(p);
    
41.     printf("==========\n");
    
42. 
    
43.     return 0;
    
44. }
    

复制代码

Cool_Breeze

void addx(std *p) 相当于 void addx （int a)
void addy(std **p) 相当于 void addy (int &a)
明白不
    addx(p);//这里不是传入的指针，是一个指针的值；
    addy(&p);//取指针变量的地址（显式地传递实参的地址）（这样才能更改它的事实参数）；

4goodworld

问题一：当我调用addx函数时，传指针，也就是一级指针时，在addx函数中  p  指针确实保存了malloc申请空间返回的地址值，但是为什么在主函数中却还是  NULL 0，函数调用中地址传递不是会改变原来这个变量的值吗，又不是值传递。
我感觉你这个问题你的困惑其实在于，指针到底是什么？说白了，指针也是一个变量，或者说也是一种数据类型的变量，
用为了说明指针的用途而常常可见的 swap()  当问你swap(int a,int b)，请问，我int aa=1，bb=2，swap（aa,bb），你告诉我aa和bb的值会不会变化？你应该会回答不会变，因为我们传递的是值，而不是地址，同理，对于当前你提问的这个指针而言，你作为参数，传递的是指针的值，这时候这个指针p与aa或者bb有啥差别？数据类型不一样而已
如果按照上面的问题一问答的结论慢慢来推导，似乎你应该可以反应过来，如果要对参数的指针变量进行改变值，那我们需要得到的是“指针”的指针，而 指针的指针 不就是对一级指针取地址，不就是二级指针吗？

wht666

Cool_Breeze 发表于 2020-5-5 15:06
void addx(std *p) 相当于 void addx （int a)
void addy(std **p) 相当于 void addy (int &a)
明白不

好的谢谢，我知道我错哪了

wht666

4goodworld 发表于 2020-5-5 15:11
问题一：当我调用addx函数时，传指针，也就是一级指针时，在addx函数中  p  指针确实保存了malloc申请空间 ...

谢谢啦，原来我一直理解错了，指针也是一个变量，只不过是存地址的变量，我一直以为是一个地址，那在函数传递也是复制过去的