[关闭]
@lishuhuakai 2015-05-18T00:23:26.000000Z 字数 4918 阅读 2603

二级指针的问题

c

如何在被调用函数里面新建数据，然后将数据的地址传递出来呢？

一般来说有两种方法,第一种思路是将数据的首地址以返回值的方法返回,第一种方法如下：

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  5. char *newBuf(int num)
  6. {
  7.     char *p;
  8.     p = (char *)malloc(num * sizeof(char));
  9.     return p;
  10. }
  11. void deleteBuf(char *p)
  12. {
  13.     if (p != NULL)
  14.     {
  15.         free(p);
  16.         p = NULL; //垃圾代码，执行了也不会有任何用处
  17.     }
  18. }
  19. void main()
  20. {
  21.     char *p = NULL;
  22.     p = newBuf(100);
  23.     printf("p :%x\n", p);
  24.     deleteBuf(p);
  25.     system("pause");
  26. }

第一种方法虽然可用，但是实际上并不好，要是需要新建多个数据然后返回呢？显然返回值不能有多个。第二种方法是利用指针的间接赋值的性质，下面是第二种方法：

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. //间接赋值是指针存在的最大意义
  6. void modifyP(int *p)
  7. {//用一级指针去修改零级指针(通常是实参)的值
  8.     *p = 20;
  9. }
  11. void main_01()
  12. {
  13.     int a = 0; //定义一个实参变量
  14.     int *p = NULL; //定义一个形参
  15.     p = &a; 
  17.     *p = 10; //间接修改a的值*(a的地址)去间接修改a的值
  18.     modifyP(&a);
  19.     printf("%d\n", a);
  20.     system("pause");
  21. }
  23. void getNewBuf(char **p)
  24. {//用二级指针(通常是形参)去修改一级指针(通常是实参)的值
  25.     //相当于在被调用函数里面分配内存，把结果给传出来了
  26.     //这就是指针做函数参数的精华
  27.     *p = 0x33;//间接修改p的值*(p的地址)去间接修改p的值
  28.     char *tmp = NULL;
  29.     tmp = (char *)malloc(100);
  30.     *p = tmp;//可以甩出被调用函数的结果
  31. }
  33. void deleteBuf(char **p)
  34. {
  35.     if (p == NULL)
  36.     {
  37.         return;
  38.     }
  39.     if (*p != NULL)
  40.     {
  41.         free(*p);
  42.     }
  43.     *p = NULL; //这一句话就不是垃圾代码了
  44. }
  45. void main()
  46. {
  47.     char *p = NULL;
  48.     char **p2 = NULL;
  50.     p = 0x11; //直接修改p的值
  51.     printf("p : %x \n", p);
  52.     p2 = &p;
  54.     //*p2 = 0x99;//间接修改p的值*(p的地址)去间接修改p的值
  55.     getNewBuf(&p);
  56.     printf("p : %x \n", p);
  57.     deleteBuf(&p);
  58.     system("pause");
  59. }

从上面可以看到，第二种方法远远优于第一种，且第二种方法更加说明了使用者对于指针的理解。

野指针问题

什么是野指针？

指针指向的空间释放之后，指针的值并未有改变，这个指针就成为了野指针。

如何避免野指针？

1. 指针定义时初始化NULL;

  1. char **myarray = NULL;

2. 释放的时候需要判断是否为NULL;

  1. if (myarray != NULL)
  2. {
  3.     free(myarray);
  4. }

3. 释放完毕之后置成NULL。

  1. if (myarray != NULL)
  2. {
  3.     free(myarray);
  4.     myarray = NULL;
  5. }

二维指针做函数参数

如何使用二级数组做函数参数？
在解决这个问题之前，我们必须先了解这么一些知识：
1. 数组做函数参数，会退化为指针。

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  5. void printfArray(int a[10])
  6. {
  7.     printf("----------printfArray----------\n");
  8.     printf("a:数组的地址:%x\n", a);
  9.     for (int i = 0; i < 10; ++i)
  10.     {
  11.         printf("%d ", a[i]);
  12.     }
  13.     printf("\n");
  14. }
  15. void main()
  16. {
  17.     int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
  18.     printf("----------main----------\n");
  19.     printf("a:数组的地址:%x\n", a);
  20.     for (int i = 0; i < 10; ++i)
  21.     {
  22.         printf("%d ", a[i]);
  23.     }
  24.     printf("\n");
  25.     printfArray(a);
  26.     system("pause");
  27. }

运行上面的代码，我们会发现，在函数printfArray中a的地址和我们传递的a数组的地址是一致的，函数并没有一个一个地拷贝数组的值。因此， 数组做函数参数，会退化为指针。
既然这样，我们可以总结出，下面三种输出函数参数的写法几乎没有区别
第一种：

  1. void printArray(int *a, int size)
  2. {
  3.     for (int i = 0; i < size; ++i)
  4.     {
  5.         printf("%d ", a[i]);
  6.     }
  7.     printf("\n");
  8. }

第二种：

  1. void printArray(int a[], int size)
  2. {
  3.     for (int i = 0; i < size; ++i)
  4.     {
  5.         printf("%d ", a[i]);
  6.     }
  7.     printf("\n");
  8. }

第三种:

  1. void printArray(int a[10])
  2. {
  3.     for (int i = 0; i < 10; ++i)
  4.     {
  5.         printf("%d ", a[i]);
  6.     }
  7.     printf("\n");
  8. }

2. 指针是一种数据类型，是指它指向的内存空间的数据类型
- 指针步长（p++），根据所致内存空间的数据类型来确定
- 指针的步长，根据所指内存空间类型来定。

3. 二维数组也是线性排列的。
看下面的代码：

  1. void printArray(int *a, int size)
  2. {
  3.     int i = 0;
  4.     printf("printArray: %d\n", sizeof(a));
  5.     for(i = 0; i < size; i++)
  6.     {
  7.         printf("%d\n", a[i]);
  8.     }
  9. }
  11. int main()
  12. {
  13.     int a[2][3] = {{1, 2, 3}, {4, 5, 6}};
  14.     printArray(p, 6);
  15.     getchar();
  16.     return 0;
  17. }

我们可以看到，函数轻易地输出了二维数组里面的值，也证明了二维数组里的值是线性排列的。

利用sizeof可以判断出指针的步长，指针的移动正是以步长为单位。下面的代码值得细细琢磨。

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  5. void printArray(int *a, int size)
  6. {//说明了二维数组里的元素线性排列
  7. //从二维数组指针转换为一维数组指针丢失了步长信息
  8.     int i = 0;
  9.     printf("-----------printArray函数中----------\n");
  10.     printf("sizeof(&a):%d \n", sizeof(&a));
  11.     printf("sizeof(a): %d\n", sizeof(a));
  12.     printf("sizeof(*a): %d\n", sizeof(*a));
  13.     printf("a数组的地址: %d\n", a);
  14.     for (i = 0; i < size; i++)
  15.     {
  16.         printf("%d ", a[i]);
  17.     }
  18.     printf("\n");
  19. }
  20. //其实下面三种函数形参的写法在编译器看来都一样，不信的话可以运行程序
  21. void printArray01(int (*a)[3], int size)
  22. {//推荐的写法
  23.     printf("-----------printArray01函数中----------\n");
  24.     printf("sizeof(&a):%d \n", sizeof(&a));
  25.     printf("sizeof(a): %d\n", sizeof(a));
  26.     printf("sizeof(*a): %d\n", sizeof(*a));
  27.     printf("a数组的地址: %d\n", a);
  29.     //printf("*a: %d\n", *a);
  30.     //printf("*a + 1: %d\n", *a + 1);
  31.     for (int i = 0; i < size; ++i)
  32.     {
  33.         for (int j = 0; j < 3; ++j)
  34.         {
  35.             printf("%d ", (*(a + i))[j]);
  36.             //printf("%x\n", (a + i) + j);
  37.         }
  39.     }
  40.     printf("\n");
  41. }
  42. void printArray02(int a[][3], int size)
  43. {/丢失了一部分的信息，3的存在标志了步长，即*a的步长为12
  44.     printf("-----------printArray02函数中----------\n");
  45.     printf("sizeof(&a):%d \n", sizeof(&a));
  46.     printf("sizeof(a): %d\n", sizeof(a));
  47.     printf("sizeof(*a): %d\n", sizeof(*a));
  48.     printf("a数组的地址: %d\n", a);
  49.     for (int i = 0; i < size; i++)
  50.     {
  51.         for (int j = 0; j < 3; ++j)
  52.         printf("%d ", a[i][j]);
  53.     }
  54.     printf("\n");
  55. }
  57. void printArray03(int a[2][3])
  58. {//虽然能用，但却是最低级的用法,即使这样写，a的步长也只不过是4
  59. //换句话说，2没起到什么作用
  60.     printf("-----------printArray03函数中----------\n");
  61.     printf("sizeof(&a):%d \n", sizeof(&a));
  62.     printf("sizeof(a): %d\n", sizeof(a));
  63.     printf("sizeof(*a): %d\n", sizeof(*a));
  64.     printf("a数组的地址: %d\n", a);
  65.     for (int i = 0; i < 2; i++)
  66.     {
  67.         for (int j = 0; j < 3; ++j)
  68.         printf("%d ", a[i][j]);
  69.     }
  70.     printf("\n");
  71. }
  74. int main()
  75. {
  76.     int a[2][3] = { { 1, 2, 3 }, { 4, 5, 6 } };
  77.     char cc[10][30];
  79.     printf("-----------main函数中----------\n");
  80.     printf("sizeof(&a):%d \n", sizeof(&a));
  81.     printf("sizeof(a):%d \n", sizeof(a));
  82.     printf("sizeof(*a):%d \n", sizeof(*a));
  83.     printf("sizeof(&cc):%d \n", sizeof(&cc));
  84.     printf("sizeof(cc):%d \n", sizeof(cc));
  85.     printf("sizeof(*cc):%d \n", sizeof(*cc));
  87.     int *p = (int *)a; 
  88.     printArray(p, 6); //即使是用二级指针，也可以输出正确的结果
  89.     printArray01(a, 2); 
  90.     printArray02(a, 2);
  91.     printArray03(a);
  92.     getchar();
  93.     return 0;
  94. }

结论倒是挺简单的：

1.C语言中只会以机械式的值拷贝的方式传递参数（实参把值传给形参）
原因有两个:
* 高效
* C语言处理a[n]的时候，它没有办法知道n是几，它只知道&a[0]是多少，因此把它的值作为参数传递进去了，虽然c语言可以做到直接int fun(char a[20])，然后函数能得到20这个数字，但是，C确实没有这么做。当然，这也提高了效率。

2.二维数组参数同样存在退化的问题。
二维数组可以看做是一维数组-->二维数组中的每个元素是一维数组-->二维数组参数中第一维的参数可以省略.
void f(int a[5]); ---> void f(int a[]); ---> void f(int* a);
void g(int a[3][3]); ---> void g(int a[][3]);---> void g(int (*a)[3]);
3. 等价关系。

数组参数 等效的指针参数
一维数组 char a[30] 指针 char*
指针数组 char *a[30] 指针的指针 char **a
二维数组 char a[10][30] 数组的指针 char(*a)[30]
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注