C++ 中将二维数组传入函数

C++ 中将二维数组传入函数

主要有三种方式

void fun(int *a[],int m,int n)//**a

void fun2(int a[][2],int m)//a[2][2]

void fun3(int (*a)[2],int m,int n)//a[2][2];int (*p)[2];p=a;

//c语言中经常需要通过函数传递二维数组，有三种方法可以实现，如下：

//方法一， 形参给出第二维的长度。

#include <stdio.h>

void func(int n, char str[][5])

{

int i;

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

{

printf("\nstr[%d] = %s\n", i, str[i]);

}

}

void main()

{

char str[][5] = {"abc", "def", "ghi"};

func(3, str);

}

//方法二，形参声明为指向数组的指针。

#include <stdio.h>

void func(int n, char (*str)[5])

{

int i;

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

{

printf("\nstr[%d] = %s\n", i, str[i]);

}

}

void main()

{

char str[][5] = {"abc", "def", "ghi"};

func(3, str);

}

//方法三，形参声明为指针的指针。

#include <stdio.h>

void func(int n, char **str)

{

int i;

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

{

printf("\nstr[%d] = %s\n", i, str[i]);

}

}

void main()

{

char *p[3];

char str[][5] = {"abc", "def", "ghi"};

p[0] = &str[0][0];

p[1] = str[1];

p[2] = str[2];

func(3, p);

}

第2个第3个都可以运行的，我在VC 6测试通过的，

第2个是数组指针，就是指向一个大小固定的数组的指针，第3个是指针的指针

***************

数组与指针有点复杂，这有个例子大家自己测试一下或许就理解了

fun1(int m[2][3][5]){;}//编译器认为是int(*m)[3][5],m是一个指向int[3][5]的指针

fun2(int m[][3][5]){;}/*同上，不信你这样测试int t[3][3][5];fun1(t);你或许会惊讶它竟然能编译通过，我也不敢相信自己的眼睛*/

fun3(int (*m)[3][5]){;}//编译器认为它是int (*m)[3][5],数组的指针是不退化的

fun4(int **m){;}

//测试一

int t[2][3][5];

fun1(t);

fun2(t);

fun3(t);

//测试二

int (*p)[3][5]=t;

fun1(p);

fun2(p);

fun3(p);

//测试三

int (*q)[2][3][5]=&t;

fun1(*q);

fun2(*q);

fun3(*q);

//测试四

int h[5][3];

int *i[5];

int **j;

int ***k;

//fun4(h);通不过编译

fun4(i);

fun4(j);

//fun4(*k);报错

//有时自己都认为指针和数组是相同的了，但它们确实有很多差别的

***********

数组与指针是怎样被编译器修改的（出自<<C专家编程>>）

ANSI C规则

1：表达式中的数组名就是指针

2：下标总是与指针的偏移量相同

3：在函数参数的声明中，数组名被当作指向该数组第一个元素的指针

实参 形参

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

指针数组 char *c[15] char **c 指针的指针

数组指针 char (*c)[64] char (*c)[64] 不变

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

***************

void average( int ary[12] ); // 形参ary是一个int *

...

int anArray[] = { 1, 2, 3 }; // 一个具有个元素的数组

const int anArraySize = sizeof(anArray)/sizeof(anArray[0]); // == 3

average( anArray ); // 合法

void average( int ary[] ); // 形参ary仍然是一个int *

****************

如果数组边界的精确数值非常重要，并且希望函数只接受含有特定数量的元素的数组，可以考虑使用一个引用形参：

void average( int (&ary)[12] );

现在函数就只能接受大小为12的整型数组：

average( anArray ); // 错误！anArray是一个int [3]！

************

int *anArray2 = new int[anArraySize];

average( anArray2 ); // 错误！不可以使用int *初始化int (&)

average_n( anArray, anArraySize ); // 没问题

*************

多维数组形参并不比一维数组来得困难，但它们看上去更具挑战性

void process( int ary[10][20] );

和一维数组的情形一样，形参不是一个数组，而是一个指向数组首元素的指针。不过，多维数组是数组的数组，因此形参是一个指向数组的指针

void process( int (*ary)[20] );// 一个指针，指向一个具有20个int元素的数组

void process( int ary[][20] ); // 仍然是一个指针，但更清晰