如何在C++中动态建立二维数组(转)

http://blog.sina.com.cn/s/blog_7c073a8d0100qp1w.html

http://blog.163.com/wujiaxing009@126/blog/static/7198839920117252550574/

http://blog.csdn.net/morewindows/article/details/7664479

http://blog.csdn.net/huazhigang/article/details/11745551

http://blog.sina.com.cn/s/blog_7c073a8d0100qp1w.html

http://www.cnblogs.com/richardcpp/archive/2012/10/15/2724406.html

http://www.cnblogs.com/lxshanye/archive/2013/05/20/3088558.html

C++中用new动态创建二维数组的格式一般是这样：

TYPE (*p)[N] = new TYPE [][N];

其中，TYPE是某种类型，N是二维数组的列数。采用这种格式，列数必须指出，而行数无需指定。在这里，p的类型是TYPE*[N]，即是指向一个有N列元素数组的指针。

还有一种方法，可以不指定数组的列数：

int **p;
p = new int*[10];    //注意，int*[10]表示一个有10个元素的指针数组
for (int i = 0; i != 10; ++i)
{
    p[i] = new int[5];
}

这里是将p作为一个指向指针的指针，它指向一个包含10个元素的指针数组，并且每个元素指向一个有5个元素的数组，这样就构建了一个10行5列的数组。

当数组使用完毕，释放空间的代码是：

for(int i = 0; i != 5; i++)
{
    delete[] p[i];
}
 delete[] p;

处理二维数组，可以用降维或是二维法。
降维法是用一位数组来接受二维数组，将二维元素的首地址&a[0][0]作为参数，传递给函数，函数用int *接受。
二维法就直接用二维数组来接受，但是需要指定列数。

double **data;

data = new double*[m]; //设置行 或直接double **data=new double*[m]; 一个指针指向一个指针数组。

for(int j=0;j<m;j++)
{
data[j] = new double[n];        //这个指针数组的每个指针元素又指向一个数组。
}

for (int i=0;i<m;i++)

{
   for (int j=0;j<n;j++)
   {
    data[i][j]=i*n+j;//初始化数组元素
   }

}

for (i=0;i<m;i++)
{
 delete[] data[i]; //先撤销指针元素所指向的数组
}                     
delete[] data; 

 

/*这种方法是通过先动态创建一个指针数组，然后为指针数组的每个元素再动态指向一个数组的办法来完成的。其创建过程与销毁过程两样重要。

在销毁的过程，先销毁指针数组每个元素指向的数组，然后再销毁这个指针数组。*/

——————————————————————————————————————————————————————————————————————————————————————————————————————

　首先：为什么需要动态定义数组呢？
  这是因为，很多情况下，在预编译过程阶段，数组的长度是不能预先知道的，必须在程序运行时动态的给出
  但是问题是，c++要求定义数组时，必须明确给定数组的大小，要不然编译通不过 
 
  如： int Array[5];正确

       int i=5;
       int Array[i]; 错误 因为在编译阶段，编译器并不知道 i 的值是多少

   那么，我们该如何解决定义长度未知的数组呢？
   答案是：new 动态定义数组 

   因为new 就是用来动态开辟空间的，所以当然可以用来开辟一个数组空间
   
   这样，下面的语句：
    int size=50;
    int *p=new int[size]; 是正确的
 
   但是二维动态数组能不能也这样定义呢
   
  int size=50,Column=50;
  int (*p)[Column]=new int [size][Column]

  这样的语句，编译器通不过，为什么呢？
  首先 new int[size][Column] 就是动态生成时确定的，所以它没有错
  那么就是 int（*p）[Column]，这句有问题了，这句为什么不对呢， 那是因为，这是一个定义语句，而定义语句先经过编译器进行编译，当编译器运行到此处时，发现Column 不是常数，因此不能通过编译。 而之所以编译器认为Column 不是常数，是因为编译阶段，编译器起的作用是查语法错误，和预分配空间，它并不执行程序，因此，没有执行那个赋值语句（只是对这个语句检查错误，和分配空间），因此编译阶段，它将认为column 是个变量。所以上面的二维数组定义是错误的， 它不能通过编译。

  改成这样：
  int size=50
  int (*p)[50]=new int [size][50]
  便正确了。

   由此可见，这种动态分配数组，仅对一维数组空间是真正动态分配的。
   但是如何真正的动态分配二维数组呢，即如果Column 也不能预先知道的话，该如何处理呢？
   
   上面的动态分配已经不能满足我们的要求，因为上面动态分配只对一维数组是真正动态的，对二维数组的话，必须编译之前预先知道二维数组每一列的长度，而这个长度在很多情况下是不能预先知道的，所以我们得结合其他方法来解决这个问题。
   
   既然一维是真正的动态分配的话，那我们利用这一特性定义一个指针数组。
   
   int **p= new int*[size];//定义指针数组 
   int *p[5];//  假若知道二维数组的行数为5

   然后对指针数组中的每一个指针分配一个一维数组空间，这样便动态定义了二维数组
  
   事实上，我认为指针数组的主要用途，就在于动态定义多维数组
    
    for(int i=0;i<size;i++)
   {
     p[i]=new int[Column];
   }
   
   运行完毕后，一个二维数组便被动态的成功建立

-----------------------------------

例子：

   size =6;

   column =5

   int **p=new int*[size];

    for(int i=0;i<size;i++)
   {
     p[i]=new int[Column];
   }

所生成的动态数组如下图所示：

 
   

  最后 ，因为调用了new, 千万千万别忘记在用完之后，将其所占资源 delete 掉

  下面是delete方法：

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

           delete []  p[i];   // 要在指针前加[] ， 否则的话 只释放p[i]所指的第一个单元所占的空间
   }

   delete [] p;     //最后不要忘掉 释放掉开辟的指针数组  ：》