C语言函数传递二维数组

C语言如果给函数传递二维数组作为参数

问题的产生

先看一个传递二维数组的例子：

#include <stdio.h>
void foo(int a[][], int m, int n)
{
    int i = 1;
    int j = 1;
    printf("a[%d][%d]=%d\n", i, j, a[i][j]);
}

int main() 
{
    int a[2][3] = {
        {1,2,3},
        {4,5,6}
    };
    foo(a, 2, 3);
}

编译：

$ gcc test.c test.
c:3:14: error: array type has incomplete element
type ‘int[]’ void foo(int p[][], int m, int n) {
^
test.c: In function ‘main’:
test.c:12:9: error: type of formal parameter 1 is incomplete
foo(a, 2, 3);

程序看着没有任何问题，但是编译器通不过，报错在处理二维数组参数a的时候，类型不兼容。

原因分析

C语言里面对二维数组的存储是按照一维数组来处理的，二维数组按照行展开的方式按顺序存储，例如在上面的例子中：
二维数组a的定义：
int a[2][3] = {
{1,2,3},
{4,5,6}
};

它等同于一维数值的定义：
int b[6] = {
{1,2,3,4,5,6}
};

因为他们的空间存储分配一样的。
—±0-±1-±2-±3-±4-±5–
—±–±-±–±-±-±------
a: | 1 | 2 | 3 | 4 | 5 | 6
b: | 1 | 2 | 3 | 4 | 5 | 6
–±--±-±–±-±-±------

所以在利用二维数组作为参数传递时，必须指定二维数组的列数，否则函数无法勾画出二维数组的组织形式。只有有了列长度，通过下标a[i][j]时才能得到正确的下标地址，即：
a[i][i] = a[ (i-1) * COLNUM + j ]

我们改一下上面的额foo函数定义：

void foo(int a[][3], int m, int n) 
{
    int i = 1;
    int j = 1;
    printf("a[%d][%d]=%d\n", i, j, a[i][j]);
}

编译运行：

$ gcc test.c
$ ./a.out
a[1][1]=5

这下就正常了。

传递二维数组的三种方法

方法1：在参数声明中指定二维数组的列数

参数如上所列。
void foo(int a[][3])

方法2：把参数声明为一个指向数组的指针

#include <stdio.h>
void foo(int (*a)[3], int m, int n) {
    int i = 1;
    int j = 1;
    printf("a[%d][%d]=%d\n", i, j, a[i][j]);
}

int main() {
    int a[2][3] = {
        {1,2,3},
        {4,5,6}
    };
    foo(a, 2, 3);
}

我们看到，函数的参数声明改成了：
int (*a)[3]

这个声明的含义是：

声明(*a)是一个数组，等价于int b[3]时，b是一个数组。
推出a是一个指针，指向一个数组，类似a是指针，指向b的。

不过此时还是需要指定二维数组的列长度，不然函数内部还是无法使用二维下标去访问数组：

#include <stdio.h>
void foo(int (*a)[], int m, int n) 
{
    int i = 1;
    int j = 1;
    printf("a[%d][%d]=%d\n", i, j, a[i][j]);
}

编译：

$ gcc test.c
test.c: In function ‘foo’:
test.c:6:5: error: invalid
use of array with unspecified bounds
printf(“a[%d][%d]=%d\n”, i, j, a[i][j]);
^

原因同前面方法1一致，如果要访问二维数组，必须指定列的长度，否则无法计算出该元素的地址，a[i][j]=a [ (i-1)*COLNUM + j ]，如果没有COLNUM，那么这个地址无法计算出来。从形参的声明来说，a就是一个指针，指向一维数组的指针，而不是一个二维数组。

方法3：把参数声明为指向指针的指针

#include <stdio.h>
void foo(int **a, int m, int n) 
{
    int i = 1;
    int j = 1;
    printf("a[%d][%d]=%d\n", i, j, a[i][j]);
}

int main() {
    int a[2][3] = {
        {1,2,3},
        {4,5,6}
    };
    int * p[3];

    p[0] = a[0];
    p[1] = a[1];
    p[2] = a[2];
    foo(p, 2, 3);
}

这里要注意的是指针的指针，和二维数组的差异；二维数组的地址是连续的，所有成员按顺序排序；而指针的指针只要求指针地址连续，而不要求指针的指针地址连续。
然后作为实参传递时，也不能直接使用a传递，因为类型不匹配，必须定义新的变量p，然后把a的值赋给p，再传递给foo函数。
请联系作者获得授权并注明出处。