C 在堆上创建多维结构数组？

我试图在堆上声明一个三维结构数组

假设我有以下结构：

struct data
{
    double x;
    double y;
};

我有：

typedef struct data data_t;

此外，尺寸如下所示：

int dim1, dim2, dim3;

---

我就是想不出一种方法来malloc一个三维结构数组

使用循环来分配内存

data_t ***3d_arrOfStruct = malloc(dim1*sizeof(data_t **); 
for(int i = 0; i < dim2; i++)
{
      3d_arrOfStruct[i] = malloc(dim2*sizeof(data_t *); 
      for(int j = 0; i < dim2; j++)
      {
           3d_arrOfStruct[i][j] = malloc(dim3*sizeof(data_t); 
      }
}  

data\t***3d\u arrOfStruct=malloc（dim1*sizeof（data\t**）；
对于（int i=0；i

请注意，这不会分配连续内存。

data\u t***arr；
data_t ***arr;

arr = malloc(sizeof(*arr) * dim1);
for (int i = 0; i < dim1; i++) {
    arr[i] =  malloc(sizeof(*arr[i]) * dim2);
    for (int j = 0; j < dim2; j++) {
        arr[i][j] =  malloc(sizeof(*arr[i][j]) * dim3);
    }
}

arr=malloc（sizeof（*arr）*dim1）；
对于（int i=0；i

如果您的多维数组不是“锯齿状”（正如您的问题所指出的那样），那么从C991开始，您只需使用一个

malloc

调用：

data_t (*p)[dim2][dim3] = malloc(dim1 * sizeof *p);

sizeof*p

已经“知道”了每个子维度的大小，因此不需要在右侧重复

dim2

和

dim3

。但是，如果您真的想重复，那么等效的调用是：

data_t (*p)[dim2][dim3] = malloc(dim1 * dim2 * dim3 * sizeof p[0][0][0]);

甚至：

data_t (*p)[dim2][dim3] = malloc(dim1 * dim2 * dim3 * sizeof(data_t));

这种方法的另一个优点是，只需要一个

免费
调用就可以将其作为一个整体进行清理

以下是可行的解决方案：

#include <stdio.h>
#include <stdlib.h>

struct data
{
    double x;
    double y;
};

typedef struct data data_t;

int main(void)
{
    int dim1 = 1, dim2 = 2, dim3 = 3;

    data_t (*p)[dim2][dim3] = malloc(dim1 * sizeof *p);

    p[0][0][0].x = 0;
    p[0][0][0].y = 0;

    printf("%f\n", p[0][0][0].x);

    free(p);

    return 0;
}

#包括
#包括
结构数据
{
双x；
双y；
};
类型定义结构数据；
内部主（空）
{
int dim1=1，dim2=2，dim3=3；
数据（*p）[dim2][dim3]=malloc（dim1*sizeof*p）；
p[0][0][0].x=0；
p[0][0][0]，y=0；
printf（“%f\n”，p[0][0][0].x）；
自由基（p）；
返回0；
}

1） 假设数组的大小在编译时是未知的。换句话说，它们不是常量表达式，但在您的问题中，
dim1
，
dim2
和
dim3
被明确表示为变量。
最简单且可能最快的是使用1d数组：

data* cube = (data*)malloc(dim1*dim2*dim3*sizeof(data));

data GetItem(int x, int y, int z)
{
   auto index = x + y * dim1 + z * dim1 * dim2;
   return cube[index];
}

我想你的意思是
sizeof（*arr[I]）
和
sizeof（*arr[I][j]）
。你使用的是什么版本的标准？一些较新版本的C有更好的特性，适用于你的问题。
malloc
和堆分配变量（也称为“动态分配变量”）如果C++是“C++”，那么你的解决方案可能是个好主意，但是，问题是标记（“平原”）“C”哦，我错过了它是C，我的道歉，而不是只使用相同的方法的Maloc。我在C++中有问题的过滤器，没有意识到它是从“其他”来显示问题。语言也是如此。