c - 为连续的二维数组分配内存

Question

我正在尝试创建一个通用函数，在调用该函数时为维数组分配连续内存。目标是实现如下所示的目标

所以要实现它 - 我使用的方程是

Type **pArray;
int total_elements = ((rows * cols) + rows); 
pArray = (Type **) malloc(total_elements * sizeof(Type));

我对访问元素部分也感到困惑。我发现很难想象下面的代码将如何填充上面数组的元素

for (row = 0; row < dim0; ++row)
   {
      for (col = 0; col < dim1; ++col)
      {
         /* For this to work Type must be a 1D array type. */
         for (ix = 0; ix < (int)(sizeof(item)/sizeof(item[0])); ++ix)
         {
            /*            printf("%4d\n", testValue); */
            ppObj[row][col][ix] = testValue;
            if (testValue == SCHAR_MAX)
               testValue = SCHAR_MIN;
            else
               ++testValue;
         }
      }
   } 

目标不是创建以下数组格式

Answer 1

这行不通。您假设您的 Type * 与您的 Type 具有相同的大小，但这在大多数情况下是不正确的。但是，无论如何，您需要行指针做什么？我的第一个实现想法是这样的:

typedef struct TypeArray
{
    size_t cols;
    Type element[];
} TypeArray;

TypeArray *TypeArray_create(size_t rows, size_t cols)
{
    TypeArray *self = calloc(1, sizeof(TypeArray) + rows * cols * sizeof(Type));
    self->cols = cols;
    return self;
}

使用例如编写 getter 和 setter self->element[row * self->cols + row]。

[编辑]:按照这里的讨论，它可以像这样:

typedef long long Type;


Type **createArray(size_t rows, size_t cols)
{
    size_t r;

    /* allocate chunk: rows times the pointer, rows * cols times the value */
    Type **array = malloc(rows * sizeof(Type *) + rows * cols * sizeof(Type));

    /* calculate pointer to first row: point directly behind the pointers,
     * then cast */
    Type *row = (Type *) (array + rows);

    /* set all row pointers */
    for (r = 0; r < rows; ++r)
    {
        array[r] = row;
        row += cols;
    }

    return array;
}

用法可能如下所示:

int main()
{
    Type **array = createArray(3, 4);

    for (int r = 0; r < 3; ++r)
    {
        for (int c = 0; c < 4; ++c)
        {
            array[r][c] = (r+1) * (c+1);
        }
    }
    for (int r = 0; r < 3; ++r)
    {
        for (int c = 0; c < 4; ++c)
        {
            printf("array[%d][%d] = %lld\n", r, c, array[r][c]);
        }
    }

    free(array);
    return 0;
}

这假设没有类型需要比数据指针更大的对齐，否则您将必须计算要在指针后面插入的填充字节数。为了安全起见，您可以使用 sizeof(Type) 和一些模计算(使用 char * 指针插入填充字节)，但这会浪费 <例如，如果您的 Type 是一个大的 struct，则需要大量内存。

总而言之，这份作业是由一位真正真正无能的老师写的。