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 (&)[n] 
 
 average_n( anArray, anArraySize ); // 没问题 
 

 ************* 
 
 多维数组形参并不比一维数组来得困难，但它们看上去更具挑战性 
 
 void process( int ary[10][20] ); 
 
 和一维数组的情形一样，形参不是一个数组，而是一个指向数组首元素的指针。不过，多维数组是数组的数组，因此形参是一个指向数组的指针 
 
 void process( int (*ary)[20] );// 一个指针，指向一个具有20个int元素的数组 
 
 void process( int ary[][20] );   // 仍然是一个指针，但更清晰