C++中动态分配二维数组

一

下面三种定义形式怎么理解？怎么动态分配空间？
(1)、int **Ptr;
(2)、int *Ptr[ 5 ]; 我更喜欢写成 int* Prt[5];
(3)、int ( *Ptr )[ 5 ];

此文引自网上，出处不详，但是觉得非常好。略改了一点。多维数组一向很难，一般都采用一维数组，但是一旦要用到还真是头疼。闲话少说，这里我就以三个二维数组的比较来展开讨论：
(1)、int **Ptr;
(2)、int *Ptr[ 5 ]; 我更喜欢写成 int* Prt[5];
(3)、int ( *Ptr )[ 5 ];
以上三例都是整数的二维数组，都可以用形如Ptr[1][1]的方式访问其内容；但它们的差别却是很大的。下面我从四个方面对它们进行讨论：
1、内容：
它们本身都是指针，它们的最终内容都是整数。注意我这里说的是最终内容，而不是中间内容，比如你写 Ptr[ 0 ]，对于三者来说，其内容都是一个整数指针，即int *；Ptr[1][1]这样的形式才是其最终内容。
2、意义：

(1)、int **Ptr 表示指向"一群"指向整数的指针的指针。
(2)、int *Ptr[ 5 ] 表示指向 5 个指向整数的指针的指针,或者说Ptr有5个指向"一群"整数的指针，Ptr是这5个指针构成的数组的地址
(3)、int ( *Ptr )[ 5 ] 表示指向"一群"指向 5 个整数数组的指针的指针。
3、所占空间：
(1)、int **Ptr 和 (3)、int ( *Ptr )[ 5 ] 一样，在32位平台里，都是4字节，即一个指针。 但(2)、int *Ptr[5] 不同，它是 5 个指针，它占5 * 4 = 20 个字节的内存空间。
4、用法：
(1)、int **Ptr 因为是指针的指针，需要两次内存分配才能使用其最终内容。首先，Ptr = (int ** )new int *[5]；这样分配好了以后，它和(2)的意义相同了；然后要分别对 5 个指针进行内存分配，例如：Ptr[0] = new int[20]; 它表示为第 0 个指针分配 20 个整数，分配好以后， Ptr[ 0 ] 为指向 20 个整数的数组。这时可以使用下标用法 Ptr[0][0] 到Ptr[0][19] 了。
如果没有第一次内存分配，该 Ptr 是个"野"指针，是不能使用的，如果没有第二次内存分配，则 Ptr[ 0 ] 等也是个"野"指针，也是不能用的。当然，用它指向某个已经定义的地址则是允许的，那是另外的用法（类似于"借鸡生蛋"的做法），这里不作讨论（下同）。

例子：

C语言：

//动态分配二维数组空间
{
   m_iHight=10;//二维数组的高度
   m_iWidth=10;//二维数组的宽度
//动态分配一个二维数组m_ppTable内存空间
//其类型为int

//m_ppTable指向该数组
   int **m_ppTable;
   m_ppTable=new int *[m_iHight];

//动态分配m_iHight个类型为int *的内存空间
//分配的是行地址空间
   for(int i=0;i
   m_ppTable[i]= new int[m_iWidth];

//动态分配m_iWidth个类型为int的内存空间
//分配的是某行的数值空间
}
//由此分配的二维数组空间并非是连续的
//可以使用m_ppTable[row][col]来给该二维数组赋值
//其中 0<=row

//释放所分配的内存空间
{
    for(int i=0;i
       delete[m_iWidth]m_ppTable[i]; //以行为单位释放数值空间
    delete [m_iHight]m_ppTable;      //释放行地址空间
}

int **a;
a=(int **)calloc(sizeof(int *),n);
for (i=0;i   a[i]=(int *)calloc(sizeof(int),n);
这样就可以了。使用的时候就和普通的二维数组一样，最后用for(i=0;i   cfree(a[i]); cfree(a);

释放内存就可以了
(2)、int *Ptr[ 5 ]
这样定义的话，编译器已经为它分配了 5 个指针的空间，这相当于(1)中的第一次内存分配。根据对(1)的讨论可知，显然要对其进行一次
内存分配的。否则就是"野"指针。
(3)、int ( *Ptr )[ 5 ]
这种定义我觉得很费解，不是不懂，而是觉得理解起来特别吃力，也许是我不太习惯这样的定义吧。怎么描述它呢？它的意义是"一群" 指针，每个指针都是指向一个 5 个整数的数组。如果想分配 k 个指针，这样写： Ptr = ( int ( * )[ 5 ] ) new int[ 5 * k ]。这是一次性的内存分配。分配好以后，Ptr 指向一片连续的地址空间，其中 Ptr[ 0 ] 指向第 0 个 5 个整数数组的首地址，Ptr[ 1 ] 指向第1 个5 个整数数组的首地址。
    综上所述，我觉得可以这样理解它们：
    int ** Ptr <==> int Ptr[ x ][ y ];
    int *Ptr[ 5 ] <==> int Ptr[ 5 ][ x ];
    int ( *Ptr )[ 5 ] <==> int Ptr[ x ][ 5 ];
这里 x 和 y 是表示若干的意思。

二

一般是三种方法：(1)用vector的vector，(2)先分配一个指针 数组，然后让里面每一个指针再指向一个数组，这个做法的好处是访问数组元素时比较直观，能用a[x][y]这样的写法，缺点是他相当于C#中的一个锯齿 数组，内存空间不连续。(3)直接分配一个x*y大小的一维数组，这样确保空间是连续的，但访问数组元素不直观。对于我这个“经典”回答，我那时还一直是 挺得意的，至少从蹭分的角度来看，这样回答还是非常有效的。

　　今天在ChinaUnix论坛闲逛时看到一个贴子，再次证实了我在C++方面才疏学浅。

　　#include <stdio.h>
　　#include <stdlib.h>
　　#include <string.h>
　　void **darray_new(int row, int col, int size)
　　{       
　　　void **arr;      
　　　arr = (void **) malloc(sizeof(void *) * row + size * row * col);      

        if (arr != NULL)      
　　 {               
　　　　void *head;               
　　　　head = (void *) arr + sizeof(void *) * row;                　　　　　　　

          memset(arr, 0, sizeof(void *) * row + size * row * col);      　　     

          while (row--)                       
　　　　　arr[row] = head + size * row * col;       
　　　 }       
　　　return arr;
　　}
　　void darray_free(void **arr)
　　{       
　　　　if (arr != NULL)               
　　　　free(arr);
　　}

　　嗯，连续分配内存，而且能用a[x][y]的方式来访问！可谓二维数组动态分配的绝妙方法！这段程式是C的，似乎要改成支持对象分配的C++版也不是什么难事（不过估计得用上placement new吧，嗯，需要再思考一下……）。

　　2007-06-13 12:38 补充:

经过试验，C++版出炉了：）关键点还是在于placement new和显示的析构函数调用，用于确保对象能正常的构造和析构。这个实现也还是有不少缺点的，比如，数组的大小必须记住，才能确保析构所有对象。不过这点能通过改进分配方法算法，把数组大小也用一点空间保存起来。
另一个缺点是，从语法上看，非常容易让人误把darray_new返回的指针以为是数据区的起始地址，从而可能导致一些逻辑错误。

　　#include <iostream>
　　#include <cstdlib>
　　#include <new>

　　template <typename T>
　　T **darray_new(int row, int col)
　　{
　　   int size = sizeof(T);
  　　  void **arr = (void **) malloc(sizeof(void *) * row + size * row * col);
  　　  if (arr != NULL)
   　　 {
    　　    unsigned char * head;
       　　 head = (unsigned char *) arr + sizeof(void *) * row;
       　　 for (int i = 0; i < row; ++i)
       　　 {
         　　   arr[i] =  head + size * i * col;
         　　   for (int j = 0; j < col; ++j)
               　　 new (head + size * (i * col + j)) T;
       　　 }
    　　}
    　　return (T**) arr;
　　}

　　template <typename T>
　　void darray_free(T **arr, int row, int col)
　　{
   　　 for (int i = 0; i < row; ++i)
       　　 for (int j = 0; j < col; ++j)
            　　arr[i][j].~T();
    　　if (arr != NULL)
        　　free((void **)arr);
　　}