0

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

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；

分配大小为 1 元素的 [36][9] 数组；malloc() 为 36 个指针分配 144 字节数组；在 003E5728 处将指针数组分配到级别 1；

分配大小为 1 元素的 [324] 数组；

003E57C0 处的 324 字节数据数组；指向 003E57C0 处的数据；将每个指针增加 9；返回分配的数组；

指向 003E5728 处的数据；将每个指针增加 9；返回分配的数组；

在 003E29E8 处分配连续数组；

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

4

2 回答 2

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;
  }
}
于 2013-02-27T18:04:28.407 回答
0

对于a ⨉ b ⨉ c ⨉ d数组，您int只需要：

int (*p)[b][c][d] = calloc(a, sizeof *p);
于 2013-02-27T18:12:01.667 回答