尝试在C中动态分配多维数组会导致崩溃

Question

出于多种原因，我希望在连续的内存块中分配多维数组。我可以通过手动分配它们来实现这一点，例如:

t.versions=(char***)malloc(sizeof(char**)*4);
t.versions[0]=(char**)malloc(sizeof(char*)*t.size*4);
t.versions[0][0]=(char*)calloc(t.size*t.size*4,sizeof(char));
for (i=1; i<t.size*4; ++i) 
    t.versions[0][i]=t.versions[0][i-1]+t.size;
for (i=1; i<4; ++i) 
    t.versions[i]=t.versions[i-1]+t.size;

在其他优点中，这个解决方案简化了释放已分配的内存:

void contiguous_array_free(void** ptr, int depth)
{
    int *ptr_d;
    ptr_d=(int*)*ptr;
    if (depth>1)
        contiguous_array_free((void**)ptr_d, depth-1);
    free(ptr);
}
//(elsewhere in the code)
contiguous_array_free((void**)(*tile).versions, 3);

现在，我有一个关于分配这些数组的小问题-虽然上面发布的方法确实有效，理想情况下，我希望有一个通用的解决方案，允许我用单个函数调用分配这些数组。

然而，我试图达到这个目标的结果是每次使用数组内容时程序都会崩溃。

//dimension points to a 1-dimensional array of integers
//specifying the size in each array dimension
void* contiguous_array_alloc(int* dimension, int depth, int size)
{
    int i;
    char** ptr;
    if (depth==1)
    {
        ptr=(char**)malloc(*dimension*size);
        return ptr;
    }
    ptr=(char**)malloc(*dimension*sizeof(char*));
    *(dimension+1)*=*dimension;
    ptr[0]=(char*)contiguous_array_alloc(dimension+1, depth-1, size);
    *(dimension+1)/=(*dimension);
    for (i=1; i<*dimension; ++i)
        ptr[i]=ptr[i-1]+(*(dimension+1)*size);
    return (void*)ptr;
}
//(later in the code) (
int dimension[3];
dimension[0]=4;
dimension[1]=t.size;
dimension[2]=t.size;
t.versions=(char***)contiguous_array_alloc(&dimension[0], 3, sizeof(char));

在代码中添加一些调试消息似乎表明元素被正确分配:

分配[4][9][9]数组大小为1的元素;Malloc()为4个指针生成16字节数组;

在003E29E8处分配指针数组到第2层

分配[36][9]数组大小为1的元素;Malloc()为36个指针生成144字节的数组;

在003E5728处分配指针数组到第1层

size为1的数组

324字节的数据数组在003E57C0;点数据在003E57C0;每个指针增加9;返回已分配数组;

点数据在003E5728;每个指针增加9;返回已分配数组;

在003E29E8处分配连续数组;

是什么导致了这种行为?我已经检查了几次代码，不知道我做错了什么

Answer 1

我认为ptr[i]=ptr[i-1]+(*(dimension+1)*size);有问题，这种指针操作的使用没有意义。我将代码修改如下，通过了4维数组的测试。

//dimension points to a 1-dimensional array of integers
//specifying the size in each array dimension
void* contiguous_array_alloc(int* dimension, int depth, int size) {
  int i;
  if (depth==2) {
    char ** ptr=(char **)malloc(*dimension * sizeof(void*));
    ptr[0]=(char *)malloc(*dimension * dimension[1] * size);
    for (i=1; i<*dimension; ++i) {
      ptr[i]=ptr[i-1]+(*(dimension+1) * size);
    }
    return (void*)ptr;
  } else {
    void ***ptr=(void***)malloc(*dimension * sizeof(void*));
    *(dimension+1)*=(*dimension);
    ptr[0]=contiguous_array_alloc(dimension+1, depth-1, size);
    *(dimension+1)/=(*dimension);
    for (i=1; i<*dimension; ++i) {
      ptr[i]=ptr[i-1]+(*(dimension+1));
    }
    return (void*)ptr;
  }
}

Answer 2

所有你需要一个⨉b ⨉c ⨉ d int数组是:

int (*p)[b][c][d] = calloc(a, sizeof *p);