二维数组的一些问题

先谈一下二维数组的动态创建和撤销，代码如下：

1.     //动态建立10*10的二维数组 
2.     int **p=new int*[10];
3.     for(int i=0;i!=10;++i)
4.     {
5.         p[i]=new int[10];
6.     }
7.     for(int a=0;a!=10;++a)
8.     {
9.         for(int b=0;b!=10;++b)
10.         {
11.             p[a][b]=a*b;
12.         }
13.     }
15.     //释放内存 
16.     for(int i=0;i!=10;++i)
17.     {
18.         delete []p[i];
19.     }
20.     delete []p;

 

  建立一个int*的数组，然后每个数组元素再去创建一个int数组，这样就建立了一个二维数组，其数组首地址是一个int**类型，这一点我们在创建的时候就看出来了。释放内存的时候就需要用一个循环来依次释放每个元素所指向的内存空间。

 

  好了，切入正题。

 

  我们现在要编写一个函数，这个函数接受一个二维数组的首地址作为参数，首先我们在桟上建立一个二维数组:

 

  int sz[10][10]={0};

 

然后我们将它作为参数传递给函数fun(),那么现在遇到了一个问题：fun的函数声明怎么写呢？

二维数组的首地址是一个指针，它指向了一个数组，这个数组的每个元素又是一个数组，那么我们接受一个int**类型可不可以呢？

 

void fun(int **p);

 

我们发现无法通过编译，原因是类型不匹配：

 

cannot convert `int (*)[10]' to `int**' for argument `1' to `void fun(int**)'

 

编译器提示我们这个二维数组的首地址是个 int (*)[10] 类型，问题就出在这，非动态创建的二维数组的首地址的类型其实是一个行指针，改写一下fun：

 

void fun(int (*p)[10]);

 

我们写一个完整的程序：

1. #include <iostream>
2. #include <iomanip>
3. using namespace std;
5. void fun(int (*p)[10])
6. {
7.     for(int a=0;a!=10;++a)
8.     {
9.         for(int b=0;b!=10;++b)
10.         {
11.             cout<<setw(4)<<setfill(' ')<<p[a][b]<<" ";
12.         }
13.         cout<<endl;
14.     }
15. }
17. int main()
18. {
19.     int sz[10][10];
20.     for(int a=0;a!=10;++a)
21.     {
22.         for(int b=0;b!=10;++b)
23.         {
24.             sz[a][b]=a*b;
25.         }
26.     }
27.     fun(sz);
28.     system("pause");
29. }

 

输出结果如下：

 

   0    0    0    0    0    0    0    0    0    0

   0    1    2    3    4    5    6    7    8    9

   0    2    4    6    8   10   12   14   16   18

   0    3    6    9   12   15   18   21   24   27

   0    4    8   12   16   20   24   28   32   36

   0    5   10   15   20   25   30   35   40   45

   0    6   12   18   24   30   36   42   48   54

   0    7   14   21   28   35   42   49   56   63

   0    8   16   24   32   40   48   56   64   72

   0    9   18   27   36   45   54   63   72   81

请按任意键继续. . .

 

  对于动态创建的二维数组，参数的类型就要看该数组创建时所用的指针类型，对于本文一开始所用的方法，fun函数就要接受一个int**类型的指针：

 

void fun(int **p);

 

  解决了这一问题之后，接下来还有一个问题，如果我们要返回一个二维数组的指针呢？

对于动态创建的来说，fun只需要声明返回一个int**就行了，但是对于桟上声明的数组来说fun函数的声明比较繁琐，这里给出两种解决方法：

 

//1.用typedef做一个类型名字的变换

typedef int(*LPSZ_T)[10];

LPSZ_T fun(LPSZ_T p);

 

//2.直接写类型，比较不容易

int (*fun(int (*p)[10]))[10];

 

在这里推荐第一种写法，但是第二种也要了解，分析一下：

 

int (*     fun(int (*p)[10])     )[10];

 

中间的表示函数名和参数表，左边的'*'表示返回一个指针，这个指针指向了一个包含10个int元素的数组。

 

文章出处：http://www.diybl.com/course/3_program/c++/cppjs/2007927/74927.html