C 三维阵列的动态内存分配

可能的重复项：

如何使用malloc分配三维阵列

array = malloc(num_elem * num_elem * num_elem * sizeof(array_elem));

为什么不呢？：）

这会管用的

int main()
{

    int ***p,i,j;

    p=(int ***) malloc(MAXX * sizeof(int **));

    for(i=0;i<MAXX;i++)
    {
        p[i]=(int **)malloc(MAXY * sizeof(int *));
        for(j=0;j<MAXY;j++)
            p[i][j]=(int *)malloc(MAXZ * sizeof(int));
    }

    for(k=0;k<MAXZ;k++)
        for(i=0;i<MAXX;i++)
            for(j=0;j<MAXY;j++)
                p[i][j][k]=<something>;
}

intmain（）
{
int***p，i，j；
p=（int***）malloc（MAXX*sizeof（int**））；
对于（i=0；i有两种不同的方法来分配3D数组。您可以将其作为一维指针数组分配给（一维指针数组分配给一维数组）。具体操作如下：

 int dim1, dim2, dim3;
 int i,j,k;
 double *** array = (double ***)malloc(dim1*sizeof(double**));

        for (i = 0; i< dim1; i++) {

         array[i] = (double **) malloc(dim2*sizeof(double *));

          for (j = 0; j < dim2; j++) {

              array[i][j] = (double *)malloc(dim3*sizeof(double));
          }

        }

要访问阵列，只需使用宏：

ARR(1,0,3) = 4;

对于给定类型T（非连续）：

size\u t dim0、dim1、dim2；
...
T***arr=malloc（sizeof*arr*dim0）；//类型*arr为T**
如果（arr）
{
尺寸i；
对于（i=0；i

除非您使用的是非常旧的（C89之前的）实现，否则不需要强制转换
malloc（）
的结果，并且不鼓励这种做法。如果您忘记包含stdlib.h，或者在范围中没有
malloc（）
的原型，编译器将键入它以返回
int
，您将得到一个“分配的类型不兼容"-键入warning。如果您强制转换结果，警告将被抑制，并且不能保证从指针到
int
再到指针的转换将是有意义的。
@Poita\n好吧，也许您是对的，但是如果有人仍然想使用分配在一个大块中的三维数组，下面是如何添加普通索引的o信息技术：

void*** newarray(int icount, int jcount, int kcount, int type_size)
{
    void*** iret = (void***)malloc(icount*sizeof(void***)+icount*jcount*sizeof(void**)+icount*jcount*kcount*type_size);
    void** jret = (void**)(iret+icount);
    char* kret = (char*)(jret+icount*jcount);
    for(int i=0;i<icount;i++)
        iret[i] = &jret[i*jcount];
    for(int i=0;i<icount;i++)
        for(int j=0;j<jcount;i++)
            jret[i*jcount+j] = &kret[i*jcount*kcount*type_size+j*kcount*type_size];
    return iret;
}

void***newarray（int-icount、int-jcount、int-kcount、int-type\u-size）
{
void***iret=（void***）malloc（icount*sizeof（void***）+icount*jcount*sizeof（void**）+icount*jcount*kcount*type\u size）；
void**jret=（void**）（iret+icount）；
char*kret=（char*）（jret+icount*jcount）；
对于（int i=0；i可能重复：我的解释不好，不好。当然，有num_elem_x，num_elem_y和num_elem_z。@AareP，分配内存更简单，但使用起来不简单。你不能用正常的[i][j][k]语法来解释它。@Poita_，在本页中添加了关于此索引语法的答案。..1）不要按C.2中的
malloc
&朋友返回的
void*
进行强制转换）
double***
等不是一个3D数组，不能作为一个数组使用！它只是碰巧在索引条目时使用了与3D数组相同的语法，但具有非常不同的语义，正如复杂的嵌套分配已经显示的那样。1）不要像C中的
malloc
&friends返回的那样强制转换
void*
。
double***
etc.不是一个3D数组，它不能作为一个数组使用！它只是在索引条目时使用了与3D数组相同的语法，但正如复杂的嵌套分配所显示的那样，它具有非常不同的语义。1）不要像C.2中的
malloc
&friends返回的那样强制转换
void*
。
double***
etc.不是3D数组，不能作为一个数组使用！它只是在索引条目时使用与3D数组相同的语法，但与复杂的嵌套分配已经显示的语义非常不同。
double***
etc.不是3D数组，不能作为一个数组使用！它只是碰巧使用与一个数组相同的语法为条目编制索引时使用3D数组，但具有非常不同的语义，如复杂的嵌套分配所示。
size_t dim0, dim1, dim2;
...
T ***arr = malloc(sizeof *arr * dim0); //type of *arr is T **
if (arr)
{
  size_t i;
  for (i = 0; i < dim0; i++)
  {
    arr[i] = malloc(sizeof *arr[i] * dim1); // type of *arr[i] is T *
    if (arr[i])
    {
      size_t j;
      for (j = 0; j < dim1; j++)
      {
        arr[i][j] = malloc(sizeof *arr[i][j] * dim2);
      }
    }
  }
}

void*** newarray(int icount, int jcount, int kcount, int type_size)
{
    void*** iret = (void***)malloc(icount*sizeof(void***)+icount*jcount*sizeof(void**)+icount*jcount*kcount*type_size);
    void** jret = (void**)(iret+icount);
    char* kret = (char*)(jret+icount*jcount);
    for(int i=0;i<icount;i++)
        iret[i] = &jret[i*jcount];
    for(int i=0;i<icount;i++)
        for(int j=0;j<jcount;i++)
            jret[i*jcount+j] = &kret[i*jcount*kcount*type_size+j*kcount*type_size];
    return iret;
}