[已解决]关于课堂上指向指针的指针的疑问

hanghanga

为什么我要用指向指针的指针？我完全可以用中间注释的方法去写，效果是一样的啊？请问这两种有什么区别？

1. #include "stdio.h"
   
2. 
   
3. int main()
   
4. {
   
5.     char *cBooks[6] = {
   
6.                     (char*)"<C程序设计语言>",
   
7.                     (char*)"<C专家编程>",
   
8.                     (char*)"<C和指针>",
   
9.                     (char*)"<C缺陷与陷阱>",
   
10.                     (char*)"<C Primer Plus>",
    
11.                     (char*)"<带你学C带你飞>"};
    
12. 
    
13.     // char *byFishC = cBooks[5];
    
14.     // char *Loves[4];
    
15.     // Loves[0] = cBooks[0];
    
16.     // Loves[1] = cBooks[1];
    
17.     // Loves[2] = cBooks[2];
    
18.     // Loves[3] = cBooks[3];
    
19. 
    
20.     char **byFishC = &cBooks[5];
    
21.     char **Loves[4];
    
22.     Loves[0] = &cBooks[0];
    
23.     Loves[1] = &cBooks[1];
    
24.     Loves[2] = &cBooks[2];
    
25.     Loves[3] = &cBooks[3];
    
26. 
    
27.     printf("大家喜爱的图书有：\n");
    
28.     printf("\t\t%s\n", *byFishC);
    
29.     printf("大家喜爱的图书有：\n");
    
30.     for (int i = 0; i < 4; i++)
    
31.     {
    
32.         printf("\t\t%s\n", *Loves[i]);
    
33.     }
    
34.    
    
35.     return 0;
    
36. }

复制代码

最佳答案

月排行榜 / 总排行榜

Mike_python小

2023-11-5 21:41:12

指向指针的指针是一个比较高级的概念，在实际编程中不一定每个人都会用到，但是了解它的原理和用法对于深入理解指针和指针数组是有帮助的。

首先我们来看一下你提供的代码。在这个例子中，我们定义了一个字符串指针数组cBooks，并初始化了其中的6个元素。然后我们使用指向指针的指针byFishC和指向指针的指针数组Loves来分别指向cBooks[5]和cBooks[0]~cBooks[3]，最后通过指针解引用符号*来输出字符串。

你提出的问题是，为什么要使用指向指针的指针？可以通过中间注释的方法来实现同样的效果。实际上，这两种方法确实可以达到同样的效果，但是它们的实现方式是不同的。

如果我们使用中间注释的方法，代码如下：

2. char *cBooks[6] = {
3.     (char*)"<C程序设计语言>",
4.     (char*)"<C专家编程>",
5.     (char*)"<C和指针>",
6.     (char*)"<C缺陷与陷阱>",
7.     (char*)"<C Primer Plus>",
8.     (char*)"<带你学C带你飞>"
9. };
11. // 指向指针的指针
12. char **byFishC = &cBooks[5];
14. // 指向指针的指针数组
15. char **Loves[4];
16. Loves[0] = &cBooks[0];
17. Loves[1] = &cBooks[1];
18. Loves[2] = &cBooks[2];
19. Loves[3] = &cBooks[3];
21. printf("大家喜爱的图书有：\n");
22. printf("\t\t%s\n", *byFishC);
24. printf("大家喜爱的图书有：\n");
25. for (int i = 0; i < 4; i++) {
26.     printf("\t\t%s\n", *Loves[i]);
27. }

复制代码

可以看到，我们使用了中间注释的方式，将byFishC和Loves定义为指向指针的指针。这样一来，我们就可以通过赋值操作将它们分别指向cBooks[5]和cBooks[0]~cBooks[3]了。在输出字符串时，我们使用指针解引用符号*，使得最终输出的是字符串本身而不是一个指针。

然而，这种实现方式并没有真正利用指向指针的指针的特性，因为我们只是将它们当作普通的指针来使用。如果我们真的要体现指向指针的指针的特性，应该这样写：

2. char *cBooks[6] = {
3.     (char*)"<C程序设计语言>",
4.     (char*)"<C专家编程>",
5.     (char*)"<C和指针>",
6.     (char*)"<C缺陷与陷阱>",
7.     (char*)"<C Primer Plus>",
8.     (char*)"<带你学C带你飞>"
9. };
11. // 指向指针的指针
12. char **byFishC = &cBooks[5];
14. // 指向指针的指针数组
15. char **Loves;
16. Loves = (char**)malloc(4 * sizeof(char *));
17. for (int i = 0; i < 4; i++) {
18.     Loves[i] = (char*)malloc((strlen(cBooks[i])+1) * sizeof(char));
19.     strcpy(Loves[i], cBooks[i]);
20. }
22. printf("大家喜爱的图书有：\n");
23. printf("\t\t%s\n", *byFishC);
25. printf("大家喜爱的图书有：\n");
26. for (int i = 0; i < 4; i++) {
27.     printf("\t\t%s\n", Loves[i]);
28. }

复制代码

这里，我们使用了malloc()函数来动态分配内存。首先，我们为Loves数组分配了4个char*类型的空间，然后用malloc()函数为每个元素分配了足够的空间来存储一个字符串。最后，我们使用strcpy()函数将cBooks数组中的字符串复制到Loves数组中。

这样一来，我们就真正利用了指向指针的指针的特性，将其用于动态分配内存和字符串操作中。可以看到，在对Loves数组进行操作时，我们并没有使用指针解引用符号*，而是直接使用了指向指针的指针Loves[i]来访问字符串。

总之，使用指向指针的指针可以更方便地实现动态分配内存和字符串操作，并且让代码更具可读性和可维护性。

球一个最佳答案谢谢啦！这对我非常重要！

跳转到最佳答案楼层

isdkz

指向指针的指针是一种非常有用的数据类型，它可以帮助我们更方便地操作指针数组。在本例中，我们需要将指针数组中的指针存储到另一个指针数组中，这时候使用指向指针的指针就可以更加方便地完成这个任务。

如果使用中间注释的方法，我们需要定义一个中间变量来存储指针数组中的指针，然后再将中间变量存储到另一个指针数组中。这种方法虽然也可以完成任务，但是需要定义多个中间变量，代码可读性不够好，而且容易出错。

因此，指向指针的指针可以帮助我们更加简洁地完成类似的任务。

Mike_python小

指向指针的指针是一个比较高级的概念，在实际编程中不一定每个人都会用到，但是了解它的原理和用法对于深入理解指针和指针数组是有帮助的。

首先我们来看一下你提供的代码。在这个例子中，我们定义了一个字符串指针数组cBooks，并初始化了其中的6个元素。然后我们使用指向指针的指针byFishC和指向指针的指针数组Loves来分别指向cBooks[5]和cBooks[0]~cBooks[3]，最后通过指针解引用符号*来输出字符串。

你提出的问题是，为什么要使用指向指针的指针？可以通过中间注释的方法来实现同样的效果。实际上，这两种方法确实可以达到同样的效果，但是它们的实现方式是不同的。

如果我们使用中间注释的方法，代码如下：

2. char *cBooks[6] = {
3.     (char*)"<C程序设计语言>",
4.     (char*)"<C专家编程>",
5.     (char*)"<C和指针>",
6.     (char*)"<C缺陷与陷阱>",
7.     (char*)"<C Primer Plus>",
8.     (char*)"<带你学C带你飞>"
9. };
11. // 指向指针的指针
12. char **byFishC = &cBooks[5];
14. // 指向指针的指针数组
15. char **Loves[4];
16. Loves[0] = &cBooks[0];
17. Loves[1] = &cBooks[1];
18. Loves[2] = &cBooks[2];
19. Loves[3] = &cBooks[3];
21. printf("大家喜爱的图书有：\n");
22. printf("\t\t%s\n", *byFishC);
24. printf("大家喜爱的图书有：\n");
25. for (int i = 0; i < 4; i++) {
26.     printf("\t\t%s\n", *Loves[i]);
27. }

复制代码

可以看到，我们使用了中间注释的方式，将byFishC和Loves定义为指向指针的指针。这样一来，我们就可以通过赋值操作将它们分别指向cBooks[5]和cBooks[0]~cBooks[3]了。在输出字符串时，我们使用指针解引用符号*，使得最终输出的是字符串本身而不是一个指针。

然而，这种实现方式并没有真正利用指向指针的指针的特性，因为我们只是将它们当作普通的指针来使用。如果我们真的要体现指向指针的指针的特性，应该这样写：

2. char *cBooks[6] = {
3.     (char*)"<C程序设计语言>",
4.     (char*)"<C专家编程>",
5.     (char*)"<C和指针>",
6.     (char*)"<C缺陷与陷阱>",
7.     (char*)"<C Primer Plus>",
8.     (char*)"<带你学C带你飞>"
9. };
11. // 指向指针的指针
12. char **byFishC = &cBooks[5];
14. // 指向指针的指针数组
15. char **Loves;
16. Loves = (char**)malloc(4 * sizeof(char *));
17. for (int i = 0; i < 4; i++) {
18.     Loves[i] = (char*)malloc((strlen(cBooks[i])+1) * sizeof(char));
19.     strcpy(Loves[i], cBooks[i]);
20. }
22. printf("大家喜爱的图书有：\n");
23. printf("\t\t%s\n", *byFishC);
25. printf("大家喜爱的图书有：\n");
26. for (int i = 0; i < 4; i++) {
27.     printf("\t\t%s\n", Loves[i]);
28. }

复制代码

这里，我们使用了malloc()函数来动态分配内存。首先，我们为Loves数组分配了4个char*类型的空间，然后用malloc()函数为每个元素分配了足够的空间来存储一个字符串。最后，我们使用strcpy()函数将cBooks数组中的字符串复制到Loves数组中。

这样一来，我们就真正利用了指向指针的指针的特性，将其用于动态分配内存和字符串操作中。可以看到，在对Loves数组进行操作时，我们并没有使用指针解引用符号*，而是直接使用了指向指针的指针Loves[i]来访问字符串。

总之，使用指向指针的指针可以更方便地实现动态分配内存和字符串操作，并且让代码更具可读性和可维护性。

球一个最佳答案谢谢啦！这对我非常重要！