二维数组作为函数的实参，定义函数形参的方法

最近讨论了一个关于二维数组做为实参传入到函数中，可以定义函数形参的方法，觉得收获挺大，总结如下：

开始时，讨论了几种方法：

1、直接用二维数组的形式，如：int array[3][4]。

2、用指向数组的指针，如：int （*p）[4]。

3、形参采用指针，如int *p，而在主函数里进行特殊操作，使二维数组传值到函数里。

4、用指向指针的指针，如：int **p。先说明这种方法是错的，分析在后面。哈哈~~~~

代码：

1. #include <iostream>  
2.  
3. using namespace std;  
4.  
5. void fun(int a[3][4])   //方法1
6. {  
7.     for (int i=0; i<3; ++i)  
8.     {  
9.         for (int j=0; j<4; ++j)  
10.         {  
11.             cout<<a[i][j]<<"\t";  
12.         }  
13.         cout<<"\n";  
14.     }     
15. }  
16.  
17. void fun1(int (*p)[4])   //方法2
18. {  
19.     for (int i=0; i<3; ++i)  
20.     {  
21.         for (int j=0; j<4; ++j)  
22.         {  
23.             cout<<p[i][j]<<"\t";  
24.         }  
25.         cout<<"\n";  
26.     }     
27. }  
28.  
29. void fun2(int *p)   //方法3
30. {  
31.     for (int i=0; i<4; ++i)  
32.     {  
33.         cout<<p[i]<<"\t";  
34.     }     
35.     cout<<"\n";  
36. }  
37.  
38. void fun3(int **p)   //方法4
39. {  
40.     for (int i=0; i<3; ++i)  
41.     {  
42.         for (int j=0; j<4; ++j)  
43.         {  
44.             cout<<p[i][j]<<"\t";  
45.         }  
46.         cout<<"\n";  
47.     }     
48. }  
49.  
50. void main()  
51. {  
52.     int a[3][4] = {0,1,2,3,4,5,6,7,8,9,10,11};  
53.     fun(a);  
54.     fun1(a);  
55.     for (int i=0; i<3; ++i)  
56.     {  
57.         fun2(*(a+i));  
58.     }  
59.     fun3(a);   //编译发生错误，int [][]不能转化为int**
60.  
61. }

正确的输出结果为： 

1. 0       1       2       3  
2. 4       5       6       7  
3. 8       9       10      11  //前三行，方法1的输出
4. 0       1       2       3  
5. 4       5       6       7  
6. 8       9       10      11  //中间三行，方法2的输出
7. 0       1       2       3  
8. 4       5       6       7  
9. 8       9       10      11  //后三行，方法3的输出
10. Press any key to continue 
    

现在来说明一下方法4的错误，可以输出a和a[0]的地址（cout<<a<<a[0];），它们的值是相同的，也 就是说二维数组不能用指向指针的指针来描述。

       当然我们可以使用动态创建数组，这样我们就可以使用方法4来定义二维数组的形参，代码如下：

1. int row = 3;  
2. int col = 4;  
3. //  
4. //创建动态二维数组  
5. int **p = new int*[row];  
6. for (int i=0; i<row; ++i)  
7. {  
8.          p[i] = new int[col];  
9. }  
10. ///  
11. for (i=0; i<row; ++i)  
12. {  
13.     for (int j=0; j<col; ++j)  
14.     {  
15.         p[i][j] = i*j+j;      //赋值  
16.     }  
17. }  
18.               
19. cout<<"p="<<p<<"\n"<<"p[0]="<<p[0]<<"\n";//输出p和p[0]的值  
20. int b[2][5] = {0};  
21. cout<<"b="<<b<<"\n"<<"b[0]="<<b[0]<<"\n";//输出b和b[0]的值  
22.  
23. fun3(p);  
24.  
25. /  
26. //记得要删除自己申请的空间  
27. for (i=0; i<row; ++i)  
28. {  
29.     delete[] p[i];  
30.     cout<<"delete p["<<i<<"]\n";  
31. }  
32. delete []p;  
33. cout<<"delete p\n";  
34. 、
35. 输出结果为：

1. 1. p=00382DF0  
   2. p[0]=00382E28   //p和p[0]的值不同
   3. b=0012FF44  
   4. b[0]=0012FF44   //b和b[0]的值相同，
   5. //但不是等价的，b代表的是b[0]的地址，而b[0]代表的是b[0][0]的地址
   6. 0       1       2       3  
   7. 0       2       4       6  
   8. 0       3       6       9   //用方法4输出的结果
   9. delete p[0]   //删除申请的空间
   10. delete p[1]  
   11. delete p[2]  
   12. delete p  
   13. Press any key to continue 
       

二维数组只能作为 连续内存单个指针来指定，而动态配的可以解决函数参数问题

原文链接：http://blog.sina.com.cn/s/blog_644949120100se70.html

这篇文章是转载的，在这里做一下修改，博主说的fun3（a）编译会出现错误，但是
 根据不同编译器不同的设置，可能出现warning 或者error,可以进行强制转换调用，可以修改为fun3（（int**）a），
有可能会出现强制转换导致地址访问错误
；