二维数组作为参数传入函数,C语言中如何将二维数组作为函数的参数传递

二维数组作为参数传入函数,C语言中如何将二维数组作为函数的参数传递详细介绍

本文目录一览： C++中二维数组作为参数传递到一个函数

可以传递二维数组作为参数，有两种方法，
方法一change(int **a)直接传递一个指针进去
方法二change(int a[][10])数组的第二维维度一定要显式指定
　　可以传递二维数组作为参数，有两种方法，
　　方法一change(int **a)直接传递一个指针进去
　　方法二change(int a[][10])数组的第二维维度一定要显式指定
　　假如主函数有一个二维数组int a[10][18];
　　写一个函数要传递二维数组，函数原型应该是这个样子
　　void f(int (*)a[18]);
　　或者 void f(int a[][18]) 必须确定第二维长度是多少
方法1、 第一维的长度可以不指定；但必须指定第二维的长度。
#include

void print_a(int a[][5], int n, int m)

{

int i, j;

for(i = 0; i < n; i++)

{

for(j = 0; j < m; j++)

printf("%d ", a[i][j]);

printf("\n");

}

}

方法2、指向一个有5个元素一维数组的指针。

void print_b(int (*a)[5], int n, int m)

{

int i, j;

for(i = 0; i < n; i++)

{

for(j = 0; j < m; j++)

printf("%d ", a[i][j]);

printf("\n");

}

}

方法3、利用数组是顺序存储的特性。

void print_c(int *a, int n, int m)

{

int i, j;

for(i = 0; i < n; i++)

{

for(j = 0; j < m; j++)

printf("%d ", *(a + i*m + j));

printf("\n");

}

}

int main(void)

{

int a[5][5] = {{1, 2}, {3, 4, 5}, {6}, {7}, {0, 8}};

printf("\n方法1:\n");

print_a(a, 5, 5);

printf("\n方法2:\n");

print_b(a, 5, 5);

printf("\n方法3:\n");

print_c(&a[0][0], 5, 5);

getch();

return 0;

}

扩展资料：printf函数使用注意事项

1、域宽

%d：按整型数据的实际长度输出。

如果想输出指定宽度可以指定域宽，%md-->m域宽,打印出来以后，在控制台上，显示m位；

如果要打印的数的位数如果超过我们设定m则原样输出；

如果要打印的数的位数如果小于设定的位数，则补空白，具体如下:

如果m为正数，则左对齐(左侧补空白)；

如果m为负数，则右对齐(右侧补空白)。

2、转义字符

如果想输出字符"%"，则应该在“格式控制”字符串中用连续两个%表示。

如：printf("%f%%",1.0/3)；输出结果：0.333333%。

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

可以用二维数组名作为实参或者形参，在被调用函数中对形参数组定义时可以指定所有维数的大小，也可以省略第一维的大小说明，如：
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);

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

很简单的,数组作为函数参数传递的时候只要是数组名就可以了,因为数组名本身就是数组的首地址 .给个程序看看

#include

#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;

}

}

直接就写数组的名称就可以了，比如你定义的数组是a[4][3]，在实参中填a就可以，在型参中定义一个二维数组或一个指针变量就可以让二维数组的值在函数中使用了！

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

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

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

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

C语言中如何将二维数组作为函数的参数传递？

函数原型 type fun (type (name*)[size])\x0d\x0a \x0d\x0atype是你要定义的类型，fun是函数名，name是在函数中二维数组的名字，\x0d\x0asize是二维数组第2维的长度。\x0d\x0a这样调用这个函数只需要把二维数组函数名传递就可以了。

C语言中如何将二维数组作为函数的参数传递

在c语言中可以用二维数组作为实参或者形参。
1、函数中用二维数组作为形参，函数声明中可以指定所有维数的大小，也可以省略第1维的维数如：
void f(int array[3][10]); //正确
void f(int array[][10]); //正确上面的两种二维数组形参表示都是正确的。
2、函数中用二维数组作为形参，不能把第2维或者更高维的大小省略，如下面的定义是不合法的：
void f(int array[][]); //错误
因为从实参传递来的是数组的起始地址，在内存中按数组排列规则存放(按行存放)，而并不区分行和列，如果在形参中不说明列数，则系统无法决定应为多少行多少列，不能只指定一维而不指定第二维，下面写法是错误的：
void f(int array[3][]); //错误 3、二维数组作为实参传递时，必须保证实参第2维的维数与形参第2维的维数相同，因为必须要保证形参和实参的数据类型一致。比如定义如下函数：
void f(int array[][10]);可以将如下数组传递给函数f。
int a[2][10] = {1,2,3,4};
int b[4][10] = {1};
函数原型 type fun (type (name*)[size])
type是你要定义的类型，fun是函数名，name是在函数中二维数组的名字，
size是二维数组第2维的长度。
这样调用这个函数只需要把二维数组函数名传递就可以了。
int fun(int **i);
fun是函数名,i就是二维数据名.
在C语言中可以用二维数组作为实参或者形参。
1、函数中用二维数组作为形参，函数声明中可以指定所有维数的大小，也可以省略第1维的维数如：
void f(int array[3][10]); //正确 void f(int array[][10]); //正确上面的两种二维数组形参表示都是正确的。
2、函数中用二维数组作为形参，不能把第2维或者更高维的大小省略，如下面的定义是不合法的：
void f(int array[][]); //错误 因为从实参传递来的是数组的起始地址，在内存中按数组排列规则存放(按行存放)，而并不区分行和列，如果在形参中不说明列数，则系统无法决定应为多少行多少列，不能只指定一维而不指定第二维，下面写法是错误的：
void f(int array[3][]); //错误 3、二维数组作为实参传递时，必须保证实参第2维的维数与形参第2维的维数相同，因为必须要保证形参和实参的数据类型一致。比如定义如下函数：
void f(int array[][10]);可以将如下数组传递给函数f。
int a[2][10] = {1,2,3,4}; int b[4][10] = {1};

关于C语言的二维数组作为函数参数的问题？

可以写成两个参数 void mini(int **a, int n)
一个参数传数组指针，一个参数传数组大小
所谓二维数组，实际上是指向数组的指针，比如：
int n=2,m=3;
int arr[n][m];
实际上相当于：
int n=2,m=3;
int (*arr)[m];
所以，传递二维数组作为参数，实际上就是传递了一个指针。
将形参的类型定义成int*，再在函数内部转换回指向数组的指针就行了，比如：
void f(int *p,int row,int column)
{
int (*arr)[column]=(int (*)[column])p;
//使用二维数组arr
}
这样传递参数：
int n=5,m=6;
int arr[n][m];
f((int*)arr,n,m);
下面是一个例子：
#include

void f(int *p,int row,int column)

{

int (*arr)[column]=(int (*)[column])p;

for(int i=0;i
<row;i++)
{

for(int j=0;j
<column-1;j++)
printf("%d,",arr[i][j]);

printf("%d\n",arr[i][column-1]);

}

}

int main()

{

int n;

scanf("%d",&n);

int arr[n][n];

for(int i=0;i
<n;i++)
{

for(int j=0;j
<n;j++)
arr[i][j]=i*n+j;

}

f((int*)arr,n,n);

return 0;

}

这是运行截图：
</n;j++)
</n;i++)
</column-1;j++)
</row;i++)

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

C语言中
指针做函数参数传递二维数组有两种基本方法：1、传递“数组指针”
<pre
t="code"

l="cpp">#include

void

output(

int

(*pa)[3],

int

n

)//这个函数只能输出n行3列的二维数组

{

int

i,j;

for(

i=0;i
<n;i++
){

for(

j=0;j<3;j++

)

printf("%d

",

pa[i][j]

);

printf("\n");

}

}

void

main()

{

int

a[2][3]={

{1,2,3},

{4,5,6}

};

output(a,2);

}2、传递“指针数组”

先将二维数组的行指针存储到一个指针数组中，再将指针数组传递到子函数中去。
<pre
t="code"

l="cpp">#include

void

output(

int

*pa[],

int

row,int

col

)

//这个函数更通用，但调用前，要做好准备工作。

{

int

i,j;

for(

i=0;i
<row;i++
){

for(

j=0;j
<col;j++
)

printf("%d

",

pa[i][j]

);

printf("\n");

}

}

void

main()

{

int

a[2][3]={

{1,2,3},

{4,5,6}

};

int

i;

int

*pa[2];

for(

i=0;i<2;i++

)

pa[i]=a[i];

output(pa,

2,

3);

}
</col;j++
</row;i++

</pre
</n;i++

</pre

C语言问题，请问二维数组的函数参数是怎么传递的？

你好！关于二维数组传参问题，
在调用的时候直接传数组指针即可，
即：
void main(){int a[10][2];shuru(a);shuchu(a);}函数形参有两种写法，可以写成
void shuru(int (*array_num)[2]){}//或者void shuru(int array_num[][2]){}函数shuchu() 也是一样，
望采纳，如有不明白请追问谢谢！
在形参是数组的情况下，只要是数组，无论维数，实际上在调用函数时，传给函数的将是一个数组的首地址，以及维数等相关信息
也就是说，在函数执行过程中，并不会新开辟内存空间，而是形参实参共用同一段内存空间
所以，在这种情况下，函数内部对数组进行修改，其值会返回给实参
你的例子中调用部分有问题，不能这样
shuru(a[10][2])
而是
shuru(a)
因为a[10][2]代表数组a中的一个元素，而且是越界的
而a才是数组名
"数组为参数时会退化为一个二级指针传递"这个理解是不对的 二维数组的形参声明应该是 int(*array_num)[2]
main里面传的实参应该是地址不是一个值，而您传的是值且还是越界了，改成shuru(a)。调用函数接受的也应该是一个地址，二维数组地址做形参写成array_num[][2]
数组为参数时会退化为一个二级指针传递，如图，可以将函数头部写成
void shuchu(int **array_num);
在函数中调用时，直接传递数组名就可以了，数组名可以视为数组的“头指针”，可以用这个指针进行一系列的相关操作，如图，可以按如下方式调用
shuchu(a);
另外，一个建议：不要在传参时忽略数组的长度，最好显式的以参数的形式传递给函数
或者，在数组中做标志，在函数中使用时可以根据标志自行分出维度
满意请采纳，不满意请追问

C语言中如何将二维字符数组作为函数参数引用传递

int fun(char a[100][20])
{
}
int main()
{
char b[100][20];
fun(b);
}
不可能达到目的。因为C语言中没有引用这类型，C++才有。另，C/C++都不支持传递数组，只能传递数组的首元素或行指针，所以即使是C++，也只能传递数组指针的引用，而不可能传递数组的引用，因为数组没有引用。

二维数组如何当参数传递

#include

#include

#define M 6

#define N 5

void getdata(int (*)[M]); \\二维数组指针做形参 的两种表达方式

void lineave(int [][M],float *);

void outdata(int [N][M],float *);

main()

{

int r[N][M];

float ave[N];

getdata(r);

lineave(r,ave);

outdata(r,ave);

}

void getdata(int (*sp)[M])

{

int i,j,x;

for(i=0;i
<n;i++)
{

j=0;

while(j
<m)
{

x=rand()%41;

if(x>=10)

{

sp[i][j]=x;j++;

}

}

}

}

void lineave(int s[][M],float *a)

{

int i,j; float ave;

for(i=0;i
<n;i++)
{

ave = 0.0;

for(j=0;j
<m;j++)ave=ave+s[i][j];
a[i]=ave/M;

}

}

void outdata(int sp[N][M],float a[])

{

int i,j;

printf("Output the result:\n");

for(i=0;i
<n;i++)
{

for(j=0;j
<m;j++)
printf("%4d",sp[i][j]);

printf(" :%6.2f\n",a[i]);

}

putchar('\n');

}

这些不知道对你有没有帮助的。

你的做法是完全正确的。

注意：C语言中数组是以指针变量形式传递的，以数组名作传递，也就是说，在子函数中修改数组值带回main函数时仍有效，非“值传递”。

二维数组时a的指针形式是int *a[]

　　在形参是数组的情况下，只要是数组，无论维数，实际上在调用函数时，传给函数的将是一个数组的首地址，以及维数等相关信息

　　也就是说，在函数执行过程中，并不会新开辟内存空间，而是形参实参共用同一段内存空间

　　所以，在这种情况下，函数内部对数组进行修改，其值会返回给实参

　　你的例子中调用部分有问题，不能这样

　　shuru(a[10][2])

　　而是

　　shuru(a)

　　因为a[10][2]代表数组a中的一个元素，而且是越界的

　　而a才是数组名
</m;j++)
</n;i++)
</m;j++)ave=ave+s[i][j];
</n;i++)
</m)
</n;i++)

定义一个函数怎么用二维数组做参数？

有两种方式：
一种为你的这种形式：
print(int a[][3],int n){}
另一种为print(int (*a)[3],int n){}
为二维数组时，第二维不能省略，并且最好与实参的第二维一样。
在调用时，只要写二维数组名即可。可以写成print（a,5）；实参数组名为a的情况下。