二维数组定义以及动态分配空间

 二维数组定义以及动态分配空间

下面三种定义形式怎么理解？怎么动态分配空间？

(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 ] 的

方式访问其内容；但它们的差别却是很大的。下面我从四个方面对它们

进行讨论：

    
一、内容：

       
它们本身都是指针，它们的最终内容都是整数。注意我这里说

的是最终内容，而不是中间内容，比如你写 Ptr[ 0 ]，对于三者来说，

其内容都是一个整数指针，即 int *；Ptr[ 1 ][ 1  
] 这样的形式才

是其最终内容。

    
二、意义：

       
(1)、int **Ptr 表示指向"一群"指向整数的指针的指针。

       
(2)、int *Ptr[ 5 ] 表示指向 5
个指向整数的指针的指针,或者说Ptr有5个指向"一群"整数的指针，Ptr是这5个指针构成的数组的地址

       
(3)、int ( *Ptr )[ 5 ] 表示指向"一群"指向 5 个整数数组的指针的指针。

    
三、所占空间：

       
(1)、int **Ptr 和 (3)、int ( *Ptr )[ 5 ] 一样，在32位平台里，都是4字节，即一个指针。

       
但 (2)、int *Ptr[ 5 ] 不同，它是 5 个指针，它占5 * 4 = 20 个字节的内存空间。

    
四、用法：

       
(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_i;//二维数组的宽度

//动态分配一个二维数组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
是表示若干的意思。

原文地址：http://www.cnblogs.com/panglei/articles/2288013.html

二维数组的动态分配和删除

二维数组的动态分配和删除

 
首先，动态支持数组的分配，必须用  
new  
来进行创建一段堆内存，其它的存贮区域不允许动态分配的产生。  

 
其次，C++并没有提供真正的动态多维数组语法，想动态分配数组，必须通过一维动态数组组合形成一个类似多维数组的存贮形式，并不像静态分配多维数组，它们的用法虽说有些地方　有相似之处，但不完全相同。  

 
再次，有些网友有一些很BT的分配方式。  

 

  例如：  

  int   (*p)[4]
= new int[3][4];  

  解释：可能有些初学者认为这样是可取的，也是利用 new
分配的数组，就可以是动态的，那你的想法就错了,它的分配必须得有最外层
const的支持—  

  int x = 3, y =
4;  

  int (*p)[y] = new
int[x][y];//error,y必须是const。  

   

 
所以这种方式不能达到真正的动态分配二维数组的目的，只能相当于半自动化的一个分配方式。  

 
那么如果依靠下面的这种方式是正确的：  

   

  例：  

  int x = 3, y =
4;  

  int *p = new int*[x];//创建一个动态 int*
型数组  

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

     
p[i] = new int[x]; //再创建一个动态 int
型数组  

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

  {  

    
　delete
p[i];//由里至外，进行释放内存。  

     
　p[i] =
NULL;//不要忘记，释放空间后p[i]不会自动指向NULL值，还将守在原处，只是释放内存而已，仅此而已。  

  }  

  delete
[]p;  

  p =
NULL;  

 

 
它就是依靠一维数组的组合来完成，这样创建的动态数组就是一个全自动的个分配方式。  

  例

  void * buf =　malloc(x * y * sizeof (int)
);  
//这也是一个好方法，简单方便，但它是C里面的分配方式。  

 
free(buf);//释放内存简单方便.  

   
原文地址：http://blog.csdn.net/jia_xiaoxin/article/details/3268645

》》》》》》转载请注明原文出处