二维数组与双重指针(转)

原文地址：https://blog.csdn.net/u013684730/article/details/46565577

一、简介

1、二维数组

    int array[10][10];
    函数声明： void fun(int a[][10])
    函数调用：fun(array);
   访问： 一般使用a[i][j]来访问数组中的元素

2、指针数组

    int *array[10];
    函数声明：void fun(int *a[10]);
    函数调用：fun(array);
    访问：使用*(a[i]+j)访问数组中的元素

3、指向指针的指针

    int **array;
    函数声明：void fun(int **a);
    函数调用：fun(array);
    访问：*(*(a+i) + j) 或者a[i][j]​访问元素（使用双重指针表示的二维数组的访问方法）

二、例题分析​

下面是一道相关的题目：

1.  
   #define ROW 2
2.  
   #define COL 3
3.  
    
4.  
   void myputs(char **pos);
5.  
    
6.  
   int main()
7.  
   {
8.  
   char **p;
9.  
   char a[ROW][COL]={"abc", "def"};
10.  
     
11.  
    p = a;
12.  
    myputs(p);
13.  
    return 0;
14.  
    }
15.  
     
16.  
    void myputs(char **p)
17.  
    {
18.  
    int i, j;
19.  
    for (i = 0; i < ROW; i++)
20.  
    {
21.  
    for (j = 0; j < COL; j++)
22.  
    printf("%c ", p[i][j]);
23.  
    printf(" ");
24.  
    }
25.  
    }

乍一看，这个题目将会打印出字符。但是实际上，这个程序运行时会出现段错误。

原因：将二维数组作为二重指针传递时，只是将数组的头指针传递给了函数，其内部结构不清楚是否能够正确访问。

改正：

方法一：将 void myputs (char **p) 改成 void myputs(char p[ROW][COL])

方法二：将char a[ROW][COL] 改成  char *a[COL]

第一种方法很好理解，肯定是可行的。我们来看看方法二。

在《C专家编程》中，讲述了参数传递过程的问题，下面就是跟我们的主题有关的内容

数组和指针参数是如何被编译器修改的？

“数组名被改写成一个指针参数”规则并不是递归定义的。数组的数组会被改写成“数组的指针”，而不是“指针的指针”：

实参                                                 所匹配的形参

数组的数组            char c[8][10];                 char (*)[10];           数组指针

指针数组              char *c[10];                   char **c;               指针的指针

数组指针(行指针)      char (*c)[10];                 char (*c)[10];          不改变

指针的指针            char **c;                      char **c;               不改变

从上面可知，形参为char **c可以匹配的参数有 char **c 和 char *c[10]。

为什么char **c可以匹配 char *c[10]， 不能匹配 char c[10][10]呢？这就跟两者的内存分布相关。

1、二维数组的内存分布：

定义了二维数组后，就会在内存中分配一块逻辑上连续的内存块。char c[10][10]，系统就会分配一块100字节的连续内存。也就是说这样的二维数组跟一维数组char c[100]具有相似的内存分布。下面我们用程序来验证：

1.  
   #define ROW 2
2.  
   #define COL 3
3.  
    
4.  
   union u
5.  
   {
6.  
   char a[ROW][COL];
7.  
   char b[ROW*COL];
8.  
   }U;
9.  
   int main()
10.  
    {
11.  
    int i, j;
12.  
    char ch = 'a';
13.  
     
14.  
    for (i = 0; i < ROW; i++)
15.  
    for (j = 0; j < COL; j++)
16.  
    {
17.  
    U.a[i][j] = ch;
18.  
    ch++;
19.  
    }
20.  
     
21.  
    for (i = 0; i < ROW; i++)
22.  
    {
23.  
    for (j = 0; j < COL; j++)
24.  
    printf("%c - %c ", U.a[i][j], U.b[i*COL + j]);
25.  
    printf(" ");
26.  
    }
27.  
    return 0;
28.  
    }

可以看出我们可以使用访问一位数组的方式来访问二维数组。

具体的内存分布如下：

这也是为什么 int a[5][] 不被允许而 int a[][4]允许的原因。

2、二维指针内存分布：

使用二维指针表示二维数组的一般动态分配方式：

1.  
   char **a;
2.  
   int i ,j;
3.  
   char ch = 'a';
4.  
   a = (char **)malloc(sizeof( char *) * ROW)
5.  
   assert(a);
6.  
   for (i = 0; i < ROW; i++)
7.  
   {
8.  
   a[i] = (char *)malloc(sizeof(char) *COL);
9.  
   assert(a[i]);
10.  
    }
11.  
     
12.  
    for (i = 0; i < ROW; i++)
13.  
    for (j = 0; j < COL; j++)
14.  
    {
15.  
    a[i][j] = ch;
16.  
    ch++;
17.  
    }

可以看出，二维数组和双重指针的内存分布完全不同，因此它们之间不能相互传递,，如果传递的话就会出现段错误。但是char *a[3]可以是因为它的内存分布跟char**a是相同的。

三、总结

char **p和char p[2][3]之间不能相互传递参数，因为它们具体的内存分布不一样，这样在运行时就会出现段错误。我们还需注意的一点：

二维数组中的a[i][j]和双重指针中的a[i][j]的意思是不一样的。

二维数组中int a[10][10]中，a[i][j]指的是第i行第j列数元素。

双重指针中int **a中， a[i][j]指的是第i个存放int *指针所指向地址中的第j个元素。也就是*(*(a+i)+j)。