C语言学习第24篇---多维数组和多维指针

知识来源主要是陈正冲老师的《C语言深度解剖》及Delphi Tang老师的《C语言剖析》和《征服C指针》，《C和指针》，有兴趣的朋友可以看我置顶文章获取

指向指针的指针

• 指针的本质是变量
• 指针会占用一定的内存空间
• 可以定义指针的指针来保存指针变量的地址值

      int main()
      {
     	int i = 0;
     	int* p = NULL;
     	int** pp = NULL;
      	pp = &p;
      	*pp = &i;
     	return 0;
      }
  
 

可能会有疑问：问什么需要指向指针的指针？

• 指针在本质上也是变量
• 对于指针也同样存在传值调用与传址调用

实例1：重置动态空间大小

      #include <stdio.h>
      #include <malloc.h>
      int reset(char**p, int size, int new_size) //定义的二维指针
      {
         int ret = 1;
         int i = 0;
         int len = 0;
         char* pt = NULL;
         char* tmp = NULL;
         char* pp = *p;
         if( (p != NULL) && (new_size > 0) ) //安全性检测
          {
              pt = (char*)malloc(new_size); //动态申请一段内存空间
              tmp = pt;
              len = (size < new_size) ? size : new_size;  //判断新分配的空间与之前的比较大小
             for(i=0; i<len; i++)
              {
                  *tmp++ = *pp++;
              }
             free(*p);
              *p = pt; //改变内存地址
          }
         else
          {
              ret = 0;
          }
         return ret;
      }
      int main()
      {
         char* p = (char*)malloc(5);
         printf("%p\n", p); //这是打印重新分配前地址值
         if( reset(&p, 5, 3) )  //假设申请的空间用不完，可以再次改变，使用reset函数，将p对应的内存空间又5变为3
          {
             printf("%p\n", p);  //实际发现变化了----就是指针的传址调用
          }
         free(p);    //释放内存
         return 0;
      }
  
 

二维数组和二维指针

• 二维数组在内存中是以一维的方式排布的
• 二维数组的第一维是一维数组
• 二维数组的第二维是具体的值
• 二维数组可以看做常量指针

如图所示：

实例2：遍历二维数组

      #include <stdio.h>
      #include <malloc.h>
      void printArray(int a[], int size)
      {
         int i = 0;
         printf("printArray: %d\n", sizeof(a));
         for(i=0; i<size; i++)
          {
             printf("%d\n", a[i]);
          }
      }
      int main()
      {
         int a[3][3] = {{0, 1, 2}, {3, 4, 5}, {6, 7, 8}}; //二维数组的初始化，这已经是矩阵的思想了
         int* p = &a[0][0];
         int i = 0;
         int j = 0;
         for(i=0; i<3; i++)
          {
             for(j=0; j<3; j++)
              {
                 printf("%d, ", *(*(a+i) + j));  //*（a+i） ==> a[i] ,*(a[i]+j) ==> a[i][j] 数组可读性好
              }
             printf("\n");
          }
         printf("\n");
         printArray(p, 9);
         return 0;
      }
  
 

数组：

• 一维数组名代表数组首元素的地址

   int a[5]    a的类型为int*

• 二维数组名同样代表数组首元素的地址

   int m[2][5]    m的类型为int(*)[5]

结论：

1. 二维数组名可以看做指向数组的常量指针
2. 二维数组可以看做是一维数组
3. 二维数组中的每一个元素都是同类型的一维数组

实例3：申请动态二维数组

      #include <stdio.h>
      #include <malloc.h>
      int** malloc2d(int row, int col) //二维指针
      {
         int** ret = NULL;
         if( (row > 0) && (col > 0) )
          {
             int* p = NULL;
              ret = (int**)malloc(row * sizeof(int*));  //先申请一个一维数组
              p = (int*)malloc(row * col * sizeof(int));  //这个之前是 p = (int*)malloc(row * col); 会造成内存越界的情况
             if( (ret != NULL) && (p != NULL) ) //安全检查
              {
                 int i = 0;
                 for(i=0; i<row; i++)
                  {
                      ret[i] = p + i * col;
                  }
              }
             else
              {
                 free(ret);
                 free(p);
                  ret = NULL;
              }
          }
         return ret;
      }
      void free2d(int** p)
      {
         if( *p != NULL )
          {
             free(*p); //释放
          }
         free(p);
      }
      int main()
      {
         int** a = malloc2d(3, 3);  //得到一个2*3的二维数组
         int i = 0;
         int j = 0;
         for(i=0; i<3; i++)
          {
             for(j=0; j<3; j++)
              {
                 printf("%d, ", a[i][j]);
              }
             printf("\n");
          }
         free2d(a);
         return 0;
      }
  
 

小结：

• 1.C语言其实只支持一维数组
• 2.C语言中的数组大小必须在编译器就作为常数确定
• 3.C语言的数组元素可是任何类型的数据
• 4.C语言的数组的元素可以是另一个数组

文章来源: allen5g.blog.csdn.net，作者：CodeAllen的博客，版权归原作者所有，如需转载，请联系作者。

原文链接：allen5g.blog.csdn.net/article/details/89110916