我们如何使用一个 malloc 语句分配二维数组

Question

我在一次采访中被问到如何分配一个二维数组，下面是我的解决方案。

#include <stdlib.h>

int **array;
array = malloc(nrows * sizeof(int *));

for(i = 0; i < nrows; i++)
{
    array[i] = malloc(ncolumns * sizeof(int));
    if(array[i] == NULL)
    {
        fprintf(stderr, "out of memory\n");
        exit or return
    }
}

我以为我做得很好，但后来他让我用一个 malloc() 声明而不是两个来做这件事。我不知道如何实现它。

谁能建议我在单个malloc() 中做到这一点？

Answer 1

只需计算nrows 行指针和实际数据所需的内存总量，将它们全部相加，然后进行一次调用：

int **array = malloc(nrows * sizeof *array + (nrows * (ncolumns * sizeof **array));

如果您认为这看起来太复杂，您可以将其拆分并通过命名大小表达式的不同术语使其有点自我记录：

int **array; /* Declare this first so we can use it with sizeof. */
const size_t row_pointers_bytes = nrows * sizeof *array;
const size_t row_elements_bytes = ncolumns * sizeof **array;
array = malloc(row_pointers_bytes + nrows * row_elements_bytes);

然后您需要遍历并初始化行指针，以便每一行的指针指向该特定行的第一个元素：

size_t i;
int * const data = array + nrows;
for(i = 0; i < nrows; i++)
  array[i] = data + i * ncolumns;

请注意，生成的结构与您获得的结构略有不同，例如int array[nrows][ncolumns]，因为我们有明确的行指针，这意味着对于这样分配的数组，并没有真正要求所有行具有相同的列数。

这也意味着像array[2][3] 这样的访问所做的事情与对实际二维数组的类似访问不同。在这种情况下，最内部的访问首先发生，array[2] 从array 的第三个元素中读取一个指针。然后将该指针视为（列）数组的基数，我们在其中索引以获取第四个元素。

相比之下，对于类似的东西

int array2[4][3];

这是一个“打包”的适当二维数组，仅占用 12 个整数的空间，像 array[3][2] 这样的访问简单地分解为向基地址添加偏移量以获取元素。

Answer 2

int **array = malloc (nrows * sizeof(int *) + (nrows * (ncolumns * sizeof(int)));

之所以可行，是因为在 C 语言中，数组只是所有元素一个接一个地作为一串字节。没有元数据或任何东西。 malloc() 不知道它是否分配用作数组中的字符、整数或行。

然后，你必须初始化：

int *offs = &array[nrows]; /*  same as int *offs = array + nrows; */
for (i = 0; i < nrows; i++, offs += ncolumns) {
    array[i] = offs;
}

Answer 3

这是另一种方法。

如果你知道编译时的列数，你可以这样做：

#define COLS ... // integer value > 0
...
size_t rows;
int (*arr)[COLS];
...              // get number of rows
arr = malloc(sizeof *arr * rows);
if (arr)
{
  size_t i, j;
  for (i = 0; i < rows; i++)
    for (j = 0; j < COLS; j++)
      arr[i][j] = ...;
}

如果您使用 C99，则可以使用指向 VLA 的指针：

size_t rows, cols;
...               // get rows and cols
int (*arr)[cols] = malloc(sizeof *arr * rows);
if (arr)
{
  size_t i, j;
  for (i = 0; i < rows; i++)
    for (j = 0; j < cols; j++)
      arr[i][j] = ...;
}

Answer 4

我们如何使用 One malloc 语句 (?) 分配二维数组

目前没有答案，为真正的二维数组分配内存。

int **array 是一个pointer to pointer to int。 array 不是指向二维数组的指针。

int a[2][3] 是一个真正的二维数组或array 2 of array 3 of int

---

要为真正的二维数组分配内存，使用 C99，使用 malloc() 并保存到指向 variable-length array (VLA) 的指针

// Simply allocate and initialize in one line of code
int (*c)[nrows][ncolumns] = malloc(sizeof *c);

if (c == NULL) {
  fprintf(stderr, "out of memory\n");
  return;
} 
// Use c
(*c)[1][2] = rand();
...
free(c);

没有VLA支持，如果维度是常数，代码可以使用

#define NROW 4
#define NCOL 5
int (*d)[NROW][NCOL] = malloc(sizeof *d);

Answer 5

你应该可以做到这一点（虽然所有的演员都很难看）：

int** array;
size_t pitch, ptrs, i;   
char* base; 
pitch = rows * sizeof(int);
ptrs = sizeof(int*) * rows;
array = (int**)malloc((columns * pitch) + ptrs);
base = (char*)array + ptrs;
for(i = 0; i < rows; i++)
{
    array[i] = (int*)(base + (pitch * i));
}

Answer 6

我不喜欢这种“指向数组的指针数组”来解决多维数组范式。总是偏爱一维数组，在使用数组 [row * cols + col] 访问元素时？将所有内容封装在一个类中并实现“at”方法没有问题。

如果您坚持使用以下符号访问数组的成员：Matrix[i][j]，您可以做一点 C++ 魔术。 @John 解决方案尝试这样做，但他需要在编译时知道列数。使用一些 C++ 并覆盖 operator[]，您可以完全做到这一点：

class Row
{
private:
    int* _p;

public:
    Row( int* p )                   { _p = p; }
    int& operator[](int col)        { return _p[col]; }
};


class Matrix
{
private:
    int* _p;
    int _cols;

public:
    Matrix( int rows, int cols )  { _cols=cols; _p = (int*)malloc(rows*cols ); }
    Row operator[](int row)       { return _p + row*_cols; }
};

所以现在，您可以使用 Matrix 对象，例如创建一个乘法表：

Matrix mtrx(rows, cols);
for( i=0; i<rows; ++i ) {
    for( j=0; j<rows; ++j ) {
        mtrx[i][j] = i*j;
    }
}

您现在应该知道优化器正在做正确的事情，并且没有调用函数或任何其他类型的开销。没有调用构造函数。只要您不在函数之间移动矩阵，就不会创建 _cols 变量。语句 mtrx[i][j] 基本上是做 mtrx[i*cols+j] 的。

Answer 7

可以这样做：

#define NUM_ROWS 10
#define NUM_COLS 10

int main(int argc, char **argv)
{
    char (*p)[NUM_COLS] = NULL;
    p = malloc(NUM_ROWS * NUM_COLS);
    memset(p, 81, NUM_ROWS * NUM_COLS);
    p[2][3] = 'a';
    for (int i = 0; i < NUM_ROWS; i++) {
        for (int j = 0; j < NUM_COLS; j++) {
            printf("%c\t", p[i][j]);
        }
        printf("\n");
    }
} // end of main

Answer 8

您可以使用 malloc 分配 (row*column) * sizeof(int) 字节的内存。 这是一个代码sn-p来演示。

int row = 3, col = 4;
int *arr = (int *)malloc(row * col * sizeof(int));

int i, j, count = 0;
for (i = 0; i <  r; i++)
  for (j = 0; j < c; j++)
     *(arr + i*col + j) = ++count; //row major memory layout

for (i = 0; i <  r; i++)
  for (j = 0; j < c; j++)
     printf("%d ", *(arr + i*col + j));