From:东北菜青虫

在C++中为数组动态分配内存的格式如下：

 

第一步：声明

       type (p)[常量1][常量2]...[常量n];

第二步：申请

       p=new type[x][常量1][常量2]...[常量n];

说明：先定义一个n维的数组指针，其中p是一个指针变量，x是一个整形变量，

      然后申请一个第一维为x的n+1维数组，记住只有第一维x可变。

举例：

   1、动态申请一个一维数组

      int *p;

      int x;

      cin>>x;

      p=new int[x];  

   2、动态申请一个二维整型数组

      int (*p)[10];

      int x;

      cin>>x;

      p=new int[x][10];

      若执行这段程序，给x输入3，则相当于定义一个3行10列的

      一个二维数组。实际是申请3102个存储单元，并把其首

      地址返回给p,通过p来操纵这个动态数组。

   3、动态申请一个三维数组

      int (*p)[8][6];

      int x;

      cin>>x;

      p=new int[x][8][6];

      

注意：

   1、申请成功与否，看p的值，若p的值为NULL,则说明申请不成功，

      反之，则申请成功。

   2、动态申请的存储单元，使用之后应及时返还给系统，方法是：

      delete p;即可。

///---------------------------------------------------------------->

malloc函数只能申请长度为size的连续空间，也就是说，它只能申请一维数组，但是你可以用一维数组代替二维数组来操作．

也可以用calloc函数来申请n个长度为size的连续空间，也就是说它也是只能申请一维数组，但它申请的格式很像二维数组．可以当作二维数组来操作．

如：

#include

#include

#include

void main()

{

    char *a;

    int x,i,j;

    cin>>x;

    a=(char *)calloc(x,2*sizeof(char));

    for(i=0;i< P>

        for(j=0;j<2;j++)

        {

            scanf("%c",&a[2*i+j]);

        }

    for(i=0;i< P>

    {

        for(j=0;j<2;j++)

        {

        printf("%c ",a[2*i+j]);

        }

        }

}

///------------------------------------------------------------>

对于a=new char[x][2]; ，C中与之相对应的动态分配方法基本相同，例如：

char (*a)[2];

a = (char(*)[2])malloc(x*2*sizeof(char));

由于第二维被定死，还没有完全达到“动态”，还可以这样做：

char **p;

int i, iRow, iColumn;

.....

p = (char**)malloc(iRow*sizeof(char*));

for(i=0; i

p[1][0] = ''A'';

.......

上面这个做法适合于整个数组尚未创建的情况，如果数据已经存在，又想改变维数，例如从一维改为二维来读取，可以这样做：

char a[100], **p;  

int i, iRow, iColumn;

p = (char**)malloc(iRow*sizeof(char*));

for(i=0; i

上面的做法还可以扩展到三维、四维甚至维数也未定的情况。

void main()

{

   char **p;

int i, iRow=2, iColumn=2;

p = (char**)malloc(iRow*sizeof(char*));

for(i=0; i

p[1][0] = ''A'';

cout<</p>

< ENDL>

}

//怎么释放二维数组内存delete []p;还是free(p)

先

for(int i=0;i< P>

delete p[i];

delete []p;

 

 

//申请2维双精度实数数组

double **alloc_2d_dbl(int m, int n)

{

              int i;

              double **new1;

 

              new1 = new double*[m];

          

    if (new1 == NULL)

              {

                     printf("ALLOC_2D_DBL: Couldn''t allocate array of dbl ptrs ");

                     return (NULL);

              }

 

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

              {

                     new1[i] = new double[n];

                     if (new1[i] == NULL)

                     {

                            printf("ALLOC_1D_DBL: Couldn''t allocate array of doubles ");

                            return (NULL);

                     }

              }

              return (new1);

}

*/

//申请2维双精度实数数组

//这段代码与上面的不同在于实际上只是申请了一块一维的动态数组，然后将其转化为二维引用（因为我的目的就是要引用二位动态数组）。

double **alloc_2d_dbl(int m, int n)

{

              int i;

              double *new1;

              double **pnew1;

 

              pnew1 = new double*[m];

              new1 = new double[m*n];

 

              if (new1 == NULL)

              {

                     printf("ALLOC_2D_DBL: Couldn''t allocate array of dbl ptrs ");

                     return (NULL);

              }

 

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

              {

                     pnew1[i] = &new1[n*i];

              }

              return (pnew1);

}