动态二维数组的用法.doc

1、动态创建二维数组
正确的做法：
方法一：
void fun(int iRow, int iCol)
{
CString** ppData;
ppData = new CString*[iRow];

for(int i=0;i< iRow;++i)
{
ppData[i] = new CString[iCol];
}
}

方法二：
void fun(int iRow, int iCol)
{
CString* pTemp;
CString** ppData;
pTemp =new CString[iRow*iCol];
ppData = new CString*[iRow];

for(int i=0;i< iRow;++i)
{
ppData[i] =&pTemp[i*iCol];
}
}

ppData就是我们创建的二维数组。

错误的做法：
void fun(int iRow, int iCol)
{
CString** ppData;
ppData = new CString[iRow][iCol];
}
错误提示：error C2540: non-constant expression as array bound

2、使用二维数组
（1）我们在应用中有时候会需要把一个二维数组作为参数传入一个函数中，这个函数的形式怎样才是正确的？
void fun(CString** str, int iRow, int iCol); 正确
void fun(CString str[][], int iRow, int iCol); 错误，没有指定数组的列数！
void fun(CString* str, int iRow, int iCol); 正确，可以在函数内部对str处理，变成一个二维数组

（2）现在我们定义了fun，
void fun(CString** str, int iRow, int iCol);
然后我们需要在外面传入一个二维数组，应该如何传入？
正确做法：
CString** test;
//分配test的空间，给test初始化值
……
fun(test, 2, 1);

错误的做法：
CString test[2][1];
//给test初始化值
……
fun(test, 2, 1);
会提示错误：cannot convert parameter 1 from 'WTL::CString [2][1]' to 'WTL::CString **'

（3）如果需要把申请的二维数组的指针传给一个struct的成员，要注意先申请struct的空间
struct Info
{
CString** data;
int x;
int y;
}
错误的语句：
Info* infoTest;
//申请ppData空间
infoTest->data = ppData; 出错！崩溃

正确的语句是：
Info* infoTest = (Info*)malloc(sizeof(Info)); 正确
//申请ppData空间
infoTest->data = ppData;

（4）删除二维指针
对于方法一创建的数组：
int j;
for(j=0;j< iRow;j++)
{
delete[] ppData[j];
}
delete[] ppData;
【注：方法一：
void fun(int iRow, int iCol)
{
CString** ppData;
ppData = new CString*[iRow];

for(int i=0;i< iRow;++i)
{
ppData[i] = new CString[iCol];
}
}
】

对于方法二创建的数组：
delete[] ppData;
delete[] pTemp;

【注：方法二：
void fun(int iRow, int iCol)
{
CString* pTemp;
CString** ppData;
pTemp =new CString[iRow*iCol];
ppData = new CString*[iRow];

for(int i=0;i< iRow;++i)
{
ppData[i] =&pTemp[i*iCol];
}
}
例如构造一个整型的二维数组：

int row,col;(设已被初始化)

int **p = new int* [row];
for(int i = 0; i < row; i++)
p[i] = new int[col];

////////////////////////////////
删除时：
for(int i = 0 i < row; i++)
delete[] p[i];
delete [] p;
---------------------------------------------------------------

看看下面的；
/*计算方法--动态开辟内存空间--yanfeng*/

/*注意：1).本程序已解决了由用户自由输入n的值，已决定矩阵中元素的个数。
2).可以通过输入行数的值x,列数的值y，来确定一个x*y大小的矩阵,但x或y的值不能为0。
3).在C++中可以通过new和delete运算符动态开辟和释放空间，和本程序有相同作用。
4).如果对数组需调用函数，实参和形参都需用指针，形参值a,b改变，实参也将跟着改变。
*/
#include <stdio.h>
#include <malloc.h>

void main()

{
int x,y,i,j;
float **a,*b;
printf("请输入你所求解的线性方程组的行数x：x=");
scanf("%d",&x);
printf("请输入你所求解的线性方程组的列数y：y=");
scanf("%d",&y);

a=(float **)malloc(sizeof(float *) *x);
b=(float *)malloc(sizeof(float) *x);
for(i=0;i<x;i++)
{
*(a+i)=(float *)malloc(sizeof(float) *y);
}

/*读入数据*/

printf("请按行的顺序依次输入系数的值(共%d项)：",x*y);
for(i=0;i<=x-1;i++)
for(j=0;j<=y-1;j++)
scanf("%f",&a[i][j]);
printf("请按列的顺序依次输入常数的值(共%d项)：",x);
for(j=0;j<=x-1;j++)
scanf("%f",&b[j]);

printf("您输入方程组的增广矩阵为：\n");
for(i=0;i<=x-1;i++)
{
for(j=0;j<=y-1;j++)
printf("%.5f ",a[i][j]);
printf("%.5f ",b[i]);
printf("\n");
}
free(b);
for(i=0;i<x;i++)
free (*(a+i));
// float choose_the_main(float **a,float *b,int k);/*形参*/
// choose_the_main(a,b,k);/*实参*/

}
在C++中动态分配内存的，对于单个变量，字符串，一维数组等，都是很容易的。C++中动态分配二维数组的方法，很少有C++语言书中描述，我查找了有的C++语言书中提到了一个方法：

假定二维数组的维数为[M][N]

分配是可以这样：
int **ptr=new int*[M]; //////这是先动态分配一个包含有M个指针的数组，即指先分配一个针数组

///////////指针数组的首地址保存在ptr中
for(int i=0;i<M;i++)
ptr[i]=new int[N]; ////////////为指针数组的每个元素赋一个地址，

////这个地址是指向一维数组的地址，也即是为针元数组的每个元素分配一个数组

一个源代码的例子为：

int **pMatrix = new int*[row]；

for(int i = 0; i < row; i++)
{
pMatrix[i] = new int[column];

for(int j = 0; j < column; j++)
{
pMatrix[i][j] = (i+j); ///////简单的初始化

}

}

这样创建一个数组有个严重的问题，就是它的内存不连续，行与行之间的内存不连续，虽然可以用[i][j]下标访问，无法满足用指向二维数组元素型别的指针变量来访问整个数组的要求

例如不能如下访问每个二维数组元素：

int * p = NULL;

for(p = pMatrix[0]; p < pMatrix[0]+column * row; p++)
{
int fff = *(pme);

}

而这种访问方式对于真正的二维数组是完全可以的。出现这种原因就是因为行与行之间的内存不连续造成的。

所以，这中方式创建的动态二维数组，不是真正意义上的二维数组。

那么什么是真正的二维数组呢？C语言中的二维数组在内存组织形式是按行存储的连续的内存区域。所以，必须保证数组元素是按行存储的，而且也是最重要的是内存要连续。

所以，我写出了如下的一个方法：

假定二维数组的元素变量类型是MyType；可以是C语言接受的除void之外的任何类型，因为编译器不晓得void类型的大小；例如int，float，double等等类型；

int row = 2; /////暂假定行数是2，这个可以在运行时刻决定；
int column = 3;/////暂假定列数是2，这个可以在运行时刻决定；

void **ptdhead = NULL; //////////在后面说明为什么要用void**类型
void **ptdBody = NULL;//////////在后面说明为什么要用void**类型

ptdhead = (void **)malloc(sizeof(void*)*row + sizeof(MyType)*row*column);

if(!ptdhead)
return FALSE;

ptdBody = ptdhead + row ;

for(int ncount = 0; ncount < row; ncount++)
ptdhead[ncount] = ptdBody + ncount * column* sizeof(MyType)/sizeof(void*);

MyType**ptdheadRealse;
ptdheadRealse = (MyType**)ptdhead;///////////////////强制转换为自己程序需要的二维数组元素类型的指针
ptdhead = NULL;

for(int i = 0; i < row; i++ )
{
for(int j = 0; j< column; j++)
{
ptdheadRealse[i][j] = i+j; ////////进行简单的初始化；
}

}

这样的一种方法动态分配的二维数组，内存是连续的，是真正意义的C语言二维数组，满足所有二维数组访问的方法，而且内存利用效率高，程序性能好。

这样一种分配方法要理解的是一下一点概念：
体会，只要是指针都可以带[],不管使直接指针，还是间接指针,都可以用下标，只要使指针就可以了，这个很关键；
另外就是要明白void*的指针是不能够用于加减法的，因为系统不晓得一个void型的大小，
但是void**指针却是可以进行加减法，进行指针偏移的,因为void*型大小使知道的，
所以，编译器使可以计算出偏移地址的。
由于void型，系统不晓得大小，所以，void *p = (void*)malloc(3); 编译器无法通过如 void *q = p+3;

我们知道假设一个整型变量nCont在32位机器上是4个字节，q是指向nCont的指针变量，q的值，也就是nCont的地址是 0x00032ec0,那么q+1的值为0x0x00032ec0+1*4,这是C语言中计算指针表达式值的方法。即q+1的值为 q+1*sizeof(int);

从这里，我们可以理解为什么我们用void**作为动态分配内存函数返回的类型，因为，如果返回的是void*类型，我们无法计算地址的偏移量，即无法计算出数组首元素的地址，也就是数组的地址。当然，我们可以不用void**,可以用除了void*的任何C中内嵌的简单类型，不过如果考虑使用起来简单，方便，那么我觉得还是悬着用void**,或者char*;选择char*类型方便的是，char类型的大小是1,那么元素的个数，即等于地址的偏移量。