Как правильно настроить, получить доступ и освободить многомерный массив в C?
Я видел десятки вопросов о том, "что не так с моим кодом" относительно многомерных массивов в C. По какой-то причине люди, кажется, не могут обернуться вокруг того, что здесь происходит, поэтому я решил ответить на этот вопрос как отсылку к другим:
Как правильно настроить, получить доступ и освободить многомерный массив в C?
Если у других есть полезные советы, пожалуйста, пишите!
4 ответа
В C начиная с C99, даже динамические многомерные массивы могут быть легко выделены за один раз с 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);
Существует как минимум четыре различных способа создания или моделирования многомерного массива в C89.
Один из них - "выделять каждую строку отдельно", - описал Майк в своем ответе. Это не многомерный массив, он просто имитирует (в частности, имитирует синтаксис для доступа к элементу). Это может быть полезно в случае, когда каждая строка имеет разный размер, поэтому вы представляете не матрицу, а что-то с "рваным краем".
Одним из них является "выделить многомерный массив". Это выглядит так:
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], В С89 NUM_COLS должен быть известен во время компиляции. Это настоящий двумерный массив.
Одним из них является "выделить 1-й массив и притвориться". Это выглядит так:
int *matrix = malloc(sizeof(int) * NUM_COLS * NUM_ROWS);
...
free(matrix);
Тогда синтаксис для доступа к элементу [i,j] matrix[NUM_COLS * i + j], Это (конечно) не настоящий двухмерный массив. На практике он имеет такую же компоновку, как и один.
Собственно говоря, это легко понять:
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;
Исходя из ответа Джен, если вы хотите выделить место для 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);
Если вы хотите использовать массив 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 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);