[已解决]为什么我用一个二级指针去尝试改变指针p却做不到呢？

a905448839

如注释

1. #include<stdio.h>
   
2. int A[4]  = {4,3,2,1};
   
3. 
   
4. void QX(int *p)
   
5. {
   
6.        
   
7.         printf("*p = %d\n",*p);//打印指针p指向的数组第一个元素
   
8. 
   
9.         printf("A的地址%d\n",A);
   
10.         printf("P的值%d\n",p);//此时P的值为main函数里数组b的地址
    
11. 
    
12.         int **pp = &p;//定义一个指向指针的指针   这个指针指向p
    
13.         *pp = A;//这个语句表示 pp指针指向的p指针的值修改为A的地址
    
14.                         //因为之前p的值数组是b的地址 现在改为数组A的地址
    
15. 
    
16.         printf("*p = %d\n",*p);//那么这里打印的是A数组第一个元素
    
17. 
    
18.        
    
19.         printf("A的地址%d\n",A);
    
20.         printf("P的值%d\n",p);
    
21.        
    
22. }
    
23. 
    
24. 
    
25. int main(void)
    
26. {
    
27. 
    
28.         int b[4] = {1,2,3,4};
    
29.         int *p = b;
    
30.        
    
31.         QX(p);//传递指针p进去
    
32.         printf("*p = %d\n",*p); //从QX函数从来并未改变指针p的值 也就是说p的指向没有改变
    
33.         //为什么我用一个二级指针去尝试改变指针p却做不到呢？
    
34. 
    
35.        
    
36. return 0;
    
37. }
    

复制代码

最佳答案

月排行榜 / 总排行榜

学习编程中的Ben

2023-8-3 21:25:00

问题分析：

在你的代码中，你尝试使用一个二级指针来改变指针 p 的值，但是发现 p 并没有被改变。让我们逐步分析一下原因：

1. 在函数 QX 内部，你定义了一个指向指针的指针 pp，并将其初始化为 &p，即 pp 指向了指针 p 的地址。

2. 接着，你尝试将 *pp 的值修改为数组 A 的地址，即 *pp = A;。由于 pp 指向了 p 的地址，这个赋值操作实际上将指针 p 的值修改为了数组 A 的地址。

3. 然后，你打印了 *p，这里输出的是数组 A 的第一个元素。这是因为前面已经将指针 p 的值修改为了数组 A 的地址。

4. 但是，在函数 main 中，当你再次打印 *p 时，你发现 p 的指向并没有改变。这是因为在函数 QX 内部，你改变的是 p 的值（也就是指针的内容），而不是 p 本身。所以在函数 main 中，p 的指向没有发生变化。

解决方案：

如果你想要在函数 QX 中改变指针 p 的指向，你可以将指针的地址传递给函数 QX，然后通过修改指针的地址来改变指针的指向。这样做可以实现指针的指向的改变。

以下是修改后的代码示例：

1. #include <stdio.h>
3. int A[4] = {4, 3, 2, 1};
5. void QX(int **pp) {
6.     printf("*pp = %d\n", **pp);  // 打印指针pp所指向的地址的值，即指针p所指向数组的第一个元素
7.     printf("A的地址 %p\n", A);  // 打印数组A的地址
8.     printf("P的值 %p\n", *pp);  // 此时P的值为main函数里指针p的地址
10.     *pp = A;  // 修改指针p的指向为数组A的地址
12.     printf("*pp = %d\n", **pp);  // 打印被修改后的指针p所指向的地址的值，即数组A的第一个元素
13.     printf("A的地址 %p\n", A);  // 打印数组A的地址
14.     printf("P的值 %p\n", *pp);  // 打印修改后的指针p的值
15. }
17. int main(void) {
18.     int b[4] = {1, 2, 3, 4};
19.     int *p = b;
21.     QX(&p);  // 传递指针p的地址给函数QX
23.     printf("*p = %d\n", *p);  // 打印指针p所指向的地址的值
25.     return 0;
26. }

复制代码

经过以上修改，你会发现指针 p 的指向成功地被改变为数组 A 的首地址。

希望以上解答能够解决你的问题。如果还有疑问，请随时提问。

如果回答对你有帮助，请给我一个最佳答案！

跳转到最佳答案楼层

isdkz

问题出在这行代码上：

1. int **pp = &p;
   

复制代码

在这里，你将指针 p 的地址赋值给了指向指针的指针 pp 。然后你尝试将 A 的地址赋值给 pp 指向的指针 p ，以此来改变 p 的指向。

然而，这种做法是错误的。因为 p 是一个普通的指针，它只能存储一个地址值，而不能存储指针的地址。所以使用二级指针 pp 去改变 p 的指向是行不通的。

正确的做法是直接将 A 的地址赋值给 p ，而不需要使用二级指针。修改代码如下：

1. void QX(int *p)
   
2. {
   
3.     printf("*p = %d\n", *p);
   
4.     printf("A的地址%d\n", A);
   
5.     printf("P的值%d\n", p);
   
6. 
   
7.     p = A;
   
8. 
   
9.     printf("*p = %d\n", *p);
   
10.     printf("A的地址%d\n", A);
    
11.     printf("P的值%d\n", p);
    
12. }
    

复制代码

这样，指针 p 的指向就会被成功改变。

Mike_python小

问题分析：

在你的代码中，你尝试使用二级指针来改变指针 p 的值，但是却没有达到预期的结果。这是因为你在函数 QX 中将二级指针 pp 指向了指针 p，然后修改了 pp 指向的值为数组 A 的地址。虽然你修改了 pp 指向的值，但并没有真正改变原始指针 p 的值。

解决方案：

要在函数中通过传递一级指针来改变指针的值，你可以使用单级指针而不是二级指针。以下是修改后的代码示例：

2. #include <stdio.h>
4. int A[4] = {4, 3, 2, 1};
6. void QX(int *p) {
7.     printf("*p = %d\n", *p); // 打印指针 p 指向的数组第一个元素
8.     printf("A的地址%d\n", A);
9.     printf("P的值%d\n", p); // 此时 p 的值为 main 函数里数组 b 的地址
11.     p = A; // 将指针 p 的值修改为数组 A 的地址
13.     printf("*p = %d\n", *p); // 打印指针 p 指向的数组第一个元素（现在为 A 数组的第一个元素）
14.     printf("A的地址%d\n", A);
15.     printf("P的值%d\n", p);
16. }
18. int main(void) {
19.     int b[4] = {1, 2, 3, 4};
20.     int *p = b;
22.     QX(p); // 传递指针 p 进去
24.     printf("*p = %d\n", *p); // 指针 p 的值没有改变（仍然为数组 b 的地址）
26.     return 0;
27. }

复制代码

在修改后的代码中，首先将指针 p 的值打印出来，然后在函数内部将指针 p 的值修改为数组 A 的地址。这样，在函数中的打印语句中就可以正确地输出数组 A 的第一个元素。但是需要注意的是，因为你传递的是指针的副本，所以在函数外部的指针 p 的值并没有被改变。

希望以上解决方案能够帮助你理解并解决问题。如果还有其他疑问，请随时提出。

学习编程中的Ben

问题分析：

在你的代码中，你尝试使用一个二级指针来改变指针 p 的值，但是发现 p 并没有被改变。让我们逐步分析一下原因：

1. 在函数 QX 内部，你定义了一个指向指针的指针 pp，并将其初始化为 &p，即 pp 指向了指针 p 的地址。

2. 接着，你尝试将 *pp 的值修改为数组 A 的地址，即 *pp = A;。由于 pp 指向了 p 的地址，这个赋值操作实际上将指针 p 的值修改为了数组 A 的地址。

3. 然后，你打印了 *p，这里输出的是数组 A 的第一个元素。这是因为前面已经将指针 p 的值修改为了数组 A 的地址。

4. 但是，在函数 main 中，当你再次打印 *p 时，你发现 p 的指向并没有改变。这是因为在函数 QX 内部，你改变的是 p 的值（也就是指针的内容），而不是 p 本身。所以在函数 main 中，p 的指向没有发生变化。

解决方案：

如果你想要在函数 QX 中改变指针 p 的指向，你可以将指针的地址传递给函数 QX，然后通过修改指针的地址来改变指针的指向。这样做可以实现指针的指向的改变。

以下是修改后的代码示例：

1. #include <stdio.h>
3. int A[4] = {4, 3, 2, 1};
5. void QX(int **pp) {
6.     printf("*pp = %d\n", **pp);  // 打印指针pp所指向的地址的值，即指针p所指向数组的第一个元素
7.     printf("A的地址 %p\n", A);  // 打印数组A的地址
8.     printf("P的值 %p\n", *pp);  // 此时P的值为main函数里指针p的地址
10.     *pp = A;  // 修改指针p的指向为数组A的地址
12.     printf("*pp = %d\n", **pp);  // 打印被修改后的指针p所指向的地址的值，即数组A的第一个元素
13.     printf("A的地址 %p\n", A);  // 打印数组A的地址
14.     printf("P的值 %p\n", *pp);  // 打印修改后的指针p的值
15. }
17. int main(void) {
18.     int b[4] = {1, 2, 3, 4};
19.     int *p = b;
21.     QX(&p);  // 传递指针p的地址给函数QX
23.     printf("*p = %d\n", *p);  // 打印指针p所指向的地址的值
25.     return 0;
26. }

复制代码

经过以上修改，你会发现指针 p 的指向成功地被改变为数组 A 的首地址。

希望以上解答能够解决你的问题。如果还有疑问，请随时提问。

如果回答对你有帮助，请给我一个最佳答案！

a905448839

因为传递进函数的是值传递
传递进QX函数的指针p和外面的main函数的指针p的地址不是同一个  也就是两个不是同一个指针p   QX函数里的指针p只是一个副本 只是他们的值都是那个数组的地址  当我尝试修改p的值   其实修改的是副本p指针的值  main函数的指针p不会改变