如何在 C 中正确设置、访问和释放多维数组？

Question

我已经看到几十个关于“我的代码有什么问题”的问题，这些问题与 C 中的多维数组有关。由于某种原因，人们似乎无法理解这里发生的事情，所以我决定将这个问题作为一个回答参考他人：

如何在 C 中正确设置、访问和释放多维数组？

如果其他人有有用的建议，请随时一起发布！

Answer 1

在 C99 以来的 C 中，即使是动态多维数组也可以轻松地使用 malloc 一次性分配并使用 free 释放：

double (*A)[n] = malloc(sizeof(double[n][n]));

for (size_t i = 0; i < n; ++i)
  for (size_t j = 0; j < n; ++j)
      A[i][j] = someinvolvedfunction(i, j);

free(A);

Answer 2

在 C89 中创建或模拟多维数组至少有四种不同的方法。

一个是“分别分配每一行”，由 Mike 在他的回答中描述。它不是多维数组，它只是模仿一个（特别是模仿访问元素的语法）。它在每行具有不同大小的情况下很有用，因此您表示的不是矩阵，而是具有“参差不齐的边缘”的东西。

一个是“分配一个多维数组”。它看起来像这样：

int (*rows)[NUM_ROWS][NUM_COLS] = malloc(sizeof *rows);
...
free(rows);

那么访问元素[i,j]的语法是(*rows)[i][j]。在 C89 中，NUM_COLS 和 NUM_ROWS 在编译时必须是已知的。这是一个真正的二维数组，rows 是指向它的指针。

一个是“分配一个行数组”。它看起来像这样：

int (*rows)[NUM_COLS] = malloc(sizeof(*rows) * NUM_ROWS);
...
free(rows);

那么访问元素[i,j]的语法是rows[i][j]。在 C89 中，NUM_COLS 必须在编译时已知。这是一个真正的二维数组。

一个是，“分配一个一维数组并假装”。它看起来像这样：

int *matrix = malloc(sizeof(int) * NUM_COLS * NUM_ROWS);
...
free(matrix);

那么访问元素[i,j]的语法是matrix[NUM_COLS * i + j]。这（当然）不是真正的二维数组。在实践中，它的布局与一个相同。

Answer 3

静态地说，这很容易理解：

int mtx[3][2] = {{1, 2},
                 {2, 3},
                 {3, 4}};

这里没有什么复杂的。 3行2列；第一列数据：1, 2, 3；第二列中的数据：2, 3, 4。 我们可以通过相同的构造访问元素：

for(i = 0; i<3; i++){
    for(j = 0; j<2; j++)
        printf("%d ", mtx[i][j]);
    printf("\n");
}
//output
//1 2
//2 3
//3 4

现在让我们从指针的角度来看这个：

括号是一个非常好的结构，可以帮助简化事情，但是当我们需要在动态环境中工作时它并没有帮助，所以我们需要从指针的角度来考虑这一点。如果我们想存储整数的“行”，我们需要一个数组：

int row[2] = {1,2};

你知道吗？我们可以像指针一样访问它。

printf("%d, %d\n",*row,*(row+1));   //prints 1, 2
printf("%d, %d\n",row[0],row[1]);   //prints 1, 2

现在，如果我们不知道一行中的值的数量，如果我们有一个指向 int 的指针，我们可以使这个数组成为动态长度，并给它一些内存：

int *row = malloc(X * sizeof(int));  //allow for X number of ints
*row = 1;        //row[0] = 1
*(row+1) = 2; //row[1] = 2
…
*(row+(X-1)) = Y; // row[x-1] = Some value y

所以现在我们有了一个动态的一维数组；单行。但是我们想要很多行，而不仅仅是一个，而且我们不知道有多少。这意味着我们需要另一个动态的一维数组，该数组的每个元素都是指向一行的指针。

//we want enough memory to point to X number of rows
//each value stored there is a pointer to an integer
int ** matrix = malloc(X * sizeof(int *));

//conceptually:
(ptr to ptr to int)     (pointer to int)
   **matrix ------------> *row1 --------> [1][2]
                          *row2 --------> [2][3]
                          *row3 --------> [3][4]

现在剩下要做的就是编写执行这些动态分配的代码：

int i, j, value = 0;

//allocate memory for the pointers to rows
int ** matrix = malloc(Rows * sizeof(int*));

//each row needs a dynamic number of elements
for(i=0; i<Rows; i++){
    // so we need memory for the number of items in each row… 
    // we could call this number of columns as well
    *(matrix + i) = malloc(X * sizeof(int));

     //While we’re in here, if we have the items we can populate the matrix
    for(j=0; j<X; j++)
        *(*(matrix+i)+j) = value; // if you deference (matrix + i) you get the row
                                  // if you add the column and deference again, you
                                  // get the actual item to store (not a pointer!)
}

现在要做的最重要的事情之一是确保在完成后释放内存。每个级别的malloc() 应该有相同数量的free() 调用，并且调用应该是FILO 顺序（malloc 调用的逆向）：

for(i=0; i<Rows; i++) 
    free(*(matrix + i));
free(matrix);

//set to NULL to clean up, matrix points to allocated memory now so let’s not use it!
matrix = NULL; 

Answer 4

如果你想使用 typedef 的数组，那就更简单了。

假设你的代码中有typedef int LabeledAdjMatrix[SIZE][SIZE];

然后您可以使用：

LabeledAdjMatrix *pMatrix = malloc(sizeof(LabeledAdjMatrix));

然后你可以写：

for (i=0; i<SIZE; i++) {
    for (j=0; j<SIZE; j++) (*parr)[i][j] = k++; /* or parr[0][i][j]... */
}

因为pArr 是指向矩阵的指针，而* 的优先级低于[]；

这就是为什么模式常见的习惯用法是 typedef the row：

typedef int LabeledAdjRow[SIZE];

然后你可以写：

LabeledAdjRow *pMatrix = malloc(sizeof(LabeledAdjRow) * SIZE);
for (i=0; i<SIZE; i++) {
    for (j=0; j<SIZE; j++) parr[i][j] = k++;
}

你也可以直接memcpy：

LabeledAdjRow *pOther = malloc(sizeof(LabeledAdjRow) * SIZE);
memcpy(pOther, pMatrix, sizeof(LabeledAdjRow) * SIZE);

Answer 5

离开 Jen 的回答，如果你想为 3D 数组分配空间，以同样的方式，你可以这样做

int(*A)[n][n] = malloc(sizeof(int[num_of_2D_arrays][n][n]));

for (size_t p = 0; p < num_of_2D_arrays; p++)
  for (size_t i = 0; i < n; i++)
    for (size_t j = 0; j < n; j++)
      A[p][i][j] = p;

for (size_t p = 0; p < num_of_2D_arrays; p++)
    printf("Outter set %lu\n", p);
    for (size_t i = 0; i < n; i++)
      for (size_t j = 0; j < n; j++)
        printf(" %d", A[p][i][j]);
      printf("\n");

free(A);