下面三种定义形式怎么理解？怎么动态分配空间？
(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 是表示若干的意思。
_______________________________________________________________
1. C语言动态分配二维数组
(1)已知第二维
Code-1
char (*a)[N];
//指向数组的指针
a = (char (*)[N])malloc(sizeof(char *) * m);
printf("%d/n", sizeof(a));
//4， 指针
printf("%d/n", sizeof(a[0]));
//N， 一维数组
free(a);
(2)已知第一维
Code-2
char* a[M];
//指针的数组
int i;
for(i=0; i<M; i++)
a[i] = (char *)malloc(sizeof(char) * n);
printf("%d/n", sizeof(a));
//4*M， 指针数组
printf("%d/n", sizeof(a[0]));
//4， 指针
for(i=0; i<M; i++)
free(a[i]);
(3)已知第一维，一次分配内存(保证内存的连续性)
Code-3
char* a[M];
//指针的数组
int i;
a[0] = (char *)malloc(sizeof(char) * M * n);
for(i=1; i<M; i++)
a[i] = a[i-1] + n;
printf("%d/n", sizeof(a));
//4*M， 指针数组
printf("%d/n", sizeof(a[0]));
//4， 指针
free(a[0]);
(4)两维都未知
Code-4
char **a;
int i;
a = (char **)malloc(sizeof(char *) * m);
//分配指针数组
for(i=0; i<m; i++)
{
a[i] = (char *)malloc(sizeof(char) * n);
//分配每个指针所指向的数组
}
printf("%d/n", sizeof(a));
//4， 指针
printf("%d/n", sizeof(a[0]));
//4， 指针
for(i=0; i<m; i++)
{
free(a[i]);
}
free(a);
(5)两维都未知，一次分配内存(保证内存的连续性)
Code-5
char **a;
int i;
a = (char **)malloc(sizeof(char *) * m);
//分配指针数组
a[0] = (char *)malloc(sizeof(char) * m * n);
//一次性分配所有空间
for(i=1; i<m; i++)
{
a[i] = a[i-1] + n;
}
printf("%d/n", sizeof(a));
//4， 指针
printf("%d/n", sizeof(a[0]));
//4， 指针
free(a[0]);
free(a);
2.C++动态分配二维数组
(1)已知第二维
Code-6
char (*a)[N];
//指向数组的指针
a = new char[m][N];
printf("%d/n", sizeof(a));
//4， 指针
printf("%d/n", sizeof(a[0]));
//N， 一维数组
delete[] a;
(2)已知第一维
Code-7
char* a[M];
//指针的数组
for(int i=0; i<M; i++)
a[i] = new char[n];
printf("%d/n", sizeof(a));
//4*M， 指针数组
printf("%d/n", sizeof(a[0]));
//4， 指针
for(i=0; i<M; i++)
delete[] a[i];
(3)已知第一维，一次分配内存(保证内存的连续性)
Code-8
char* a[M];
//指针的数组
a[0] = new char[M*n];
for(int i=1; i<M; i++)
a[i] = a[i-1] + n;
printf("%d/n", sizeof(a));
//4*M， 指针数组
printf("%d/n", sizeof(a[0]));
//4， 指针
delete[] a[0];
(4)两维都未知
Code-9
char **a;
a = new char* [m];
//分配指针数组
for(int i=0; i<m; i++)
{
a[i] = new char[n];
//分配每个指针所指向 的数组
}
printf("%d/n", sizeof(a));
//4， 指针
printf("%d/n", sizeof(a[0]));
//4， 指针
for(i=0; i<m; i++)
delete[] a[i];
delete[] a;
(5)两维都未知，一次分配内存(保证内存的连续性)
Code-10
char **a;
a = new char* [m];
a[0] = new char[m * n];
//一次性分配 所有空间
for(int i=1; i<m; i++)
{
a[i] = a[i-1] + n;
//分配每个指针所指向的 数组
}
printf("%d/n", sizeof(a));
//4， 指针
printf("%d/n", sizeof(a[0]));
//4， 指针
delete[] a[0];
delete[] a;
多说一句：new和delete要注意配对使用，即有多少个 new就有多少个delete，这样才可以避免内存泄漏！
3.静态二维数组作为函数参数传递
如果采用上述几种方法动态分配二维数组，那么将对应的数据类型作为函数参数就可以了。这里讨论静态二维数组作为函数参数传递，即按照以下的调用 方式：
int a[2][3];
func(a);
C语言中将静态二维数组作为参数传递比较麻烦，一般需要指明第二维的长度，如果不给定第二维长度，则只能先将其作为一维指针传递，然后利用二维 数组的线性存储特性，在函数体内转化为对指定元素的访问。
首先写好测试代码，以验证参数传递的正确性：
(1)给定第二维长度
Code-11
void func(int a[][N])
{
printf("%d/n", a[1][2]);
}
(2)不给定第二维长度
Code-12
void func(int* a)
{
printf("%d/n", a[1 * N + 2]);
// 计算元素位置
}
注意：使用该函数时需要将二维数组首地址强制转换为一维指针，即func((int*)a);
1. C语言动态分配二维数组
(1)已知第二维
Code-1
char (*a)[N];
//指向数组的指针
a = (char (*)[N])malloc(sizeof(char *) * m);
printf("%d/n", sizeof(a));
//4， 指针
printf("%d/n", sizeof(a[0]));
//N， 一维数组
free(a);
(2)已知第一维
Code-2
char* a[M];
//指针的数组
int i;
for(i=0; i<M; i++)
a[i] = (char *)malloc(sizeof(char) * n);
printf("%d/n", sizeof(a));
//4*M， 指针数组
printf("%d/n", sizeof(a[0]));
//4， 指针
for(i=0; i<M; i++)
free(a[i]);
(3)已知第一维，一次分配内存(保证内存的连续性)
Code-3
char* a[M];
//指针的数组
int i;
a[0] = (char *)malloc(sizeof(char) * M * n);
for(i=1; i<M; i++)
a[i] = a[i-1] + n;
printf("%d/n", sizeof(a));
//4*M， 指针数组
printf("%d/n", sizeof(a[0]));
//4， 指针
free(a[0]);
(4)两维都未知
Code-4
char **a;
int i;
a = (char **)malloc(sizeof(char *) * m);
//分配指针数组
for(i=0; i<m; i++)
{
a[i] = (char *)malloc(sizeof(char) * n);
//分配每个指针所指向的数组
}
printf("%d/n", sizeof(a));
//4， 指针
printf("%d/n", sizeof(a[0]));
//4， 指针
for(i=0; i<m; i++)
{
free(a[i]);
}
free(a);
(5)两维都未知，一次分配内存(保证内存的连续性)
Code-5
char **a;
int i;
a = (char **)malloc(sizeof(char *) * m);
//分配指针数组
a[0] = (char *)malloc(sizeof(char) * m * n);
//一次性分配所有空间
for(i=1; i<m; i++)
{
a[i] = a[i-1] + n;
}
printf("%d/n", sizeof(a));
//4， 指针
printf("%d/n", sizeof(a[0]));
//4， 指针
free(a[0]);
free(a);
2.C++动态分配二维数组
(1)已知第二维
Code-6
char (*a)[N];
//指向数组的指针
a = new char[m][N];
printf("%d/n", sizeof(a));
//4， 指针
printf("%d/n", sizeof(a[0]));
//N， 一维数组
delete[] a;
(2)已知第一维
Code-7
char* a[M];
//指针的数组
for(int i=0; i<M; i++)
a[i] = new char[n];
printf("%d/n", sizeof(a));
//4*M， 指针数组
printf("%d/n", sizeof(a[0]));
//4， 指针
for(i=0; i<M; i++)
delete[] a[i];
(3)已知第一维，一次分配内存(保证内存的连续性)
Code-8
char* a[M];
//指针的数组
a[0] = new char[M*n];
for(int i=1; i<M; i++)
a[i] = a[i-1] + n;
printf("%d/n", sizeof(a));
//4*M， 指针数组
printf("%d/n", sizeof(a[0]));
//4， 指针
delete[] a[0];
(4)两维都未知
Code-9
char **a;
a = new char* [m];
//分配指针数组
for(int i=0; i<m; i++)
{
a[i] = new char[n];
//分配每个指针所指向 的数组
}
printf("%d/n", sizeof(a));
//4， 指针
printf("%d/n", sizeof(a[0]));
//4， 指针
for(i=0; i<m; i++)
delete[] a[i];
delete[] a;
(5)两维都未知，一次分配内存(保证内存的连续性)
Code-10
char **a;
a = new char* [m];
a[0] = new char[m * n];
//一次性分配 所有空间
for(int i=1; i<m; i++)
{
a[i] = a[i-1] + n;
//分配每个指针所指向的 数组
}
printf("%d/n", sizeof(a));
//4， 指针
printf("%d/n", sizeof(a[0]));
//4， 指针
delete[] a[0];
delete[] a;
多说一句：new和delete要注意配对使用，即有多少个 new就有多少个delete，这样才可以避免内存泄漏！
3.静态二维数组作为函数参数传递
如果采用上述几种方法动态分配二维数组，那么将对应的数据类型作为函数参数就可以了。这里讨论静态二维数组作为函数参数传递，即按照以下的调用 方式：
int a[2][3];
func(a);
C语言中将静态二维数组作为参数传递比较麻烦，一般需要指明第二维的长度，如果不给定第二维长度，则只能先将其作为一维指针传递，然后利用二维 数组的线性存储特性，在函数体内转化为对指定元素的访问。
首先写好测试代码，以验证参数传递的正确性：
(1)给定第二维长度
Code-11
void func(int a[][N])
{
printf("%d/n", a[1][2]);
}
(2)不给定第二维长度
Code-12
void func(int* a)
{
printf("%d/n", a[1 * N + 2]);
// 计算元素位置
}
注意：使用该函数时需要将二维数组首地址强制转换为一维指针，即func((int*)a);
