c语言中怎么用二维数组作为函数参数

Posted 2023-05-15

总是提示出错

二维数组作为函数参数，实参可以直接使用二维数组名，在被调用函数中对形参数组定义可以指定所有维数的大小，也可以省略第一维的大小说明，如：

它们是合法且等价，也可以使用如下形式：

但不能省略第二维的大小，如下面的定义是不合法的，编译时会出错：

因为从实参传递来的是数组的起始地址，如果在形参中不说明列数，编译器将无法定位元素的的位置。

参考技术A 可以用二维数组名作为实参或者形参，在被调用函数中对形参数组定义时可以指定所有维数的大小，也可以省略第一维的大小说明，如：

void Func(int array[3][10]);

void Func(int array[][10]);

二者都是合法而且等价，但是不能把第二维或者更高维的大小省略，如下面的定义是不合法的：

void Func(int array[][]);

因为从实参传递来的是数组的起始地址，在内存中按数组排列规则存放(按行存放)，而并不区分行和列，如果在形参中不说明列数，则系统无法决定应为多少行多 少列，不能只指定一维而不指定第二维，下面写法是错误的：

void Func(int array[3][]);实参数组维数可以大于形参数组，例如实参数组定义为：

void Func(int array[3][10]);

而形参数组定义为：

int array[5][10];

这时形参数组只取实参数组的一部分，其余部分不起作用。

对于数组 int p[m][n];

如果要取p[i][j]的值(i>=0 && i<m && 0<=j && j < n)，编译器是这样寻址的，它的地址为：

p + i*n + j;

void Func(int array[3][10]);

void Func(int array[][10]);

变为：

void Func(int **array, int m, int n);

在转变后的函数中，array[i][j]这样的式子是不对的(不信，大家可以试一下)，因为编译器不能正确的为它寻址，所以我们需要模仿编译器的行为把array[i][j]这样的式子手工转变为：

*((int*)array + n*i + j);

在调用这样的函数的时候，需要注意一下，如下面的例子：

int a[3][3] =



1, 1, 1,

2, 2, 2,

3, 3, 3

;

Func(a, 3, 3);

根据不同编译器不同的设置，可能出现warning 或者error,可以进行强制转换如下调用：

Func((int**)a, 3, 3);

其实多维数组和二维数组原理是一样的，大家可以自己扩充的多维数组，这里不再赘述。写到这里，我先向看了这篇文章后悔的人道歉，浪费你的时间了。下面是一 个完整的例子程序，这个例子程序的主要功能是求一个图中某个顶点到其他顶点的最短路经，图是以邻接矩阵的形式存放的(也就是一个二维数组)，其实这个函数 也是挺有用的，但是我们这篇文章的重点在于将二维数组作为函数的参数传递。 参考技术B 很简单的,数组作为函数参数传递的时候只要是数组名就可以了,因为数组名本身就是数组的首地址 .给个程序看看

#include<stdio.h>
#define N 3
int array[N][N];
void main()

//在主函数内声明被调函数
void convert(int array[][3]);
int i,j;
printf("输入数组:\n");
for(j=0;j<N;j++)
for(i=0;i<N;i++)
scanf("%d",&array[i][j]);
printf("\n");
for(j=0;j<N;j++)

for(i=0;i<N;i++)
printf("%d\t",array[i][j]);
printf("\n");

//调用矩阵转置函数
convert(array);
printf("\n");
for(i=0;i<N;i++)

for(j=0;j<N;j++)
printf("%d\t",array[i][j]);
printf("\n");


void convert(int array[][3])

int i,j,t;
for(i=0;i<N;i++)
for(j=0;j<N;j++)//设置数组中转置矩阵元素交换

t=array[i][j];
array[i][j]=array[j][i];
array[j][i]=t;

本回答被提问者采纳 参考技术C 直接就写数组的名称就可以了，比如你定义的数组是a[4][3]，在实参中填a就可以，在型参中定义一个二维数组或一个指针变量就可以让二维数组的值在函数中使用了！ 参考技术D 可以用指针的形式表示，或者用二维数组显示表示

C语言如何在子函数中对主函数中的二维数组值进行修改？ 二维数组已经在主函数中用动态数组分配了空间。

参考技术A 用指针做函数参数可以实现！追问

这个我也知道，问题是我怎么改都不对，要不我也不会到这来问了。您有没有源码示例一下？谢谢！

参考技术B 用数组时，必须要知道二维数组的后一个维度，否则无法正确修改，比如：
void modify(int a[][10])

a[1][2] = 12;
a[2][5] = 25;

void main()

int a[5][10];
a[1][2] = 0;
a[2][5] = 0;
modify(a);
printf("a(1,2)=%d, a(2,5)=%d\n",12, 25);


用指针方式实现时要注意二维数组的建立过程。比如以上的int a[5][10]，用指针实现相同功能的代码如下：
void modify(int **a)

a[1][2] = 12;
a[2][5] = 25;


void main()

int **a;
a = (int **) malloc( sizeof(int *) *5);
for(int i=0 ; i<5 ; i++)
a[i]=(int *) malloc(sizeof(int)*10);
a[1][2] = 0;
a[2][5] = 0;
modify(a);
printf("a(1,2)=%d, a(2,5)=%d\n",12, 25);
追问

这样很死板，我想写个通用点的，因为我的二维数组维数在变化，尤其是最后一个维度在变化。如果在子函数的形参中固定了最后一个维度的话，就没有任何灵活性了。我给子函数传了数组的首地址，然后在子函数中用一维数组的形式赋值（我主要是想赋值），但是在主函数中调用数组时值不对，也就是说值并没有被修改，不是说二维数组在内存中也是按列排列的么？难道在子函数中这个列就不管用了？

追答

　　如果用二维数组，以上用指针实现的过程中把维数设成变量就可以了，但是这样初始化时稍微有点儿麻烦。
　　　还有一种做法，就是使用一维数组来存储二维数据的值，比如把int a[5][10]转换为int a[50]，在读取时进行坐标转换，效果也是一样的，如：
int getelement(int *a, int i, int j)

return a[i*10+j];

void setelement(int *a, int i, int j, int value)

a[i*10+j] = value;

void modify(int *a)

setelement(a, 1, 2, 12);
setelement(a, 2, 5, 25);


void main()

int *a;
a = (int *) malloc( 5*10*sizeof(int*));
modify(a);
printf("a(1,2)=%d, a(2,5)=%d\n",getelement(a,1,2),getelement(a,2,5));

追问

　如果用二维数组，以上用指针实现的过程中把维数设成变量就可以了，但是这样初始化时稍微有点儿麻烦

----------------------

这点没怎么看明白，能否请您把这个说详细点？有例子更好了。谢谢！

追答

第一、就是在前面用二维数组实现的例子中，把5和10改成二维数组的行数和列数就可以了，如：
int m, n;
int **a; /* 二维数组的动态实现只能使用int**类型，这样才可以用a[i][j]方式访问数组元素*/
m = 5, n = 10; /* m 行 n 列的数组 */
a = (int **) malloc( m*sizeof(int *)); /* 这里分配的只是一个指向每一行的指针 */
for(int i=0 ; i<m; i++) /* 稍微有点儿麻烦指这两行，因为还需要给每个行指针分配内存 */
a[i]=(int *) malloc(sizeof(int)*n); /* 这里才是给每行分配存储空间，否则值就是随机的 */
这样，只要设置好行数和列数，调用函数modify(int**)就可以方便地使用二维数组了。
动态二维数组必须象这样初始化，不能写成
a = (int **) malloc( m*n*sizeof(int *));
因为这样其实是分配了m*n个元素的一维数组，使用a[i][j]的方式得到的结果是错误的。

第二、原问题中提到的“二维数组在内存中也是按列排列的”是不对的，在C语言中二维数组是按行排列的，而且这一点儿对于动态创建的二维数组是不成立的，动态二维数组本质上是一个指针数组，和直接用int a[5][10]创建的按行排列的数组有本质的区别。
如果在主程序中用int a[行数][列数]；的形式创建二维数组，因为元素是按行排列的，在子程序中就可以按一维数组的方式换算二维数组的坐标：a[i][j] 对应于一维的a[i*列数+j]，比如：
void modify(int a[], int col) /* col 是数组的列数，必须要知道列数才能转换二维数组 */

a[1*col+2] = 12345;
a[2*col+5] = 67890;


void main()

int a[5][10], i, j, k;
for ( i = 0, k = 1; i < 5; ++i )
for ( j = 0; j < 10; ++j )
a[i][j] = k++;

printf("修改前：a(1,2)=%d, a(2,5)=%d\n",a[1][2],a[2][5]);
modify((int*)a, 10);
printf("修改后：a(1,2)=%d, a(2,5)=%d\n",a[1][2],a[2][5]);


第三、如上两种方法使用的二维数组int**和int[行数][列数]定义的方式，在使用时是不一样的。int**方式只能按二维数组使用，不能象以上这样转换为一维数组使用。要想实现与静态定义的数组一样可以转换为一维数组访问的int**形式的二维数组，在初始化阶段就会更加复杂一些。
这里字数不够贴代码了，如果需要这种代码，请继续追问。

追问

int **a; /* 二维数组的动态实现只能使用int**类型，这样才可以用a[i][j]方式访问数组元素*/

--------
这点是不是有误啊？好像用浮点型也行啊。
请给出后面的代码，谢谢！

追答

　　嗯嗯，当然，用 float **, double **, struct **等等都是可以的，我说的只能用int**是必须使用**，不是说只能用int。

　　要让**方式定义的动态数组能够象静态数组那样可以用一维数组访问，就要使动态数组拥有象静态数组那样的连续内存区域，这样建立的动态数组即可以用modify1D()按1维数组访问，也可以用modify2D()按2维数组访问，但是由于内部结构不同，静态数组不能用modify2D()按动态数组方式访问，只能按1维形式使用。代码实现如下：

#include
#include
typedef int ELEMENT_TYPE; /* 数组元素类型，可以是任意类型 */
void modify1D(ELEMENT_TYPE a[], int col)
/* 按1维形式访问列数为col的二维数组 */
a[1*col+2] = 12345;
a[2*col+5] = 67890;


void modify2D(ELEMENT_TYPE **a)

a[1][2] = 12345;
a[2][5] = 67890;


ELEMENT_TYPE** make2DArray(int m, int n)
/* 建立二维数组 */
ELEMENT_TYPE **a, *b;
int i;
a = (int **)malloc(m * sizeof(int*));
b = (int *)malloc(m * n * sizeof(int));
for ( i = 0; i < m; ++i)
a[i] = b + i * n;
return a;


void free2DArray(ELEMENT_TYPE **a)
/* 释放二维数组占用的内存，与建立二维数组的过程对应 */
free(&a[0][0]);
free(a);


void main()

ELEMENT_TYPE ** a;
ELEMENT_TYPE b[5][10];
a = make2DArray(5, 10); /* 建立具有连续内存区域的二维动态数组 */

a[1][2] = 12, a[2][5] = 25;
printf("修改前：a(1,2)=%d, a(2,5)=%d\n",a[1][2],a[2][5]);
modify1D(&a[0][0], 10); /* 这里不能用(int*)a或a[0]调用，必须用&a[0][0] */
printf("修改后：a(1,2)=%d, a(2,5)=%d\n",a[1][2],a[2][5]);

a[1][2] = 12, a[2][5] = 25;
printf("修改前：a(1,2)=%d, a(2,5)=%d\n",a[1][2],a[2][5]);
modify2D(a);
printf("修改后：a(1,2)=%d, a(2,5)=%d\n",a[1][2],a[2][5]);
free2DArray(a);

b[1][2] = 12, b[2][5] = 25;
printf("修改前：b(1,2)=%d, b(2,5)=%d\n",b[1][2],b[2][5]);
modify1D((int*)b, 10); /* 这里可以用 (int*)b 或 b[0] 或 &b[0][0] 三种方式 */
printf("修改后：b(1,2)=%d, b(2,5)=%d\n",b[1][2],b[2][5]);

本回答被提问者和网友采纳