Матрица int с указателями на C - путаница с распределением памяти

Освободить каждую строку нужно отдельно:

void free_matrix(int **matrix, int size_x)
{
    for(int i = 0; i < size_x; i++)
        free(matrix[i]);
    free(matrix);
}

Вы освободили только первую строку (или столбец) first_matrix. Напишите другую функцию вроде этой:

void free_matrix(int **matrix, int rows)
{
    int i;
    for(i=0; i<rows; i++)
    {
        free(matrix[i]);
    }
    free(matrix);
}

Возможно, вы захотите превратить матрицу в структуру для хранения количества строк и столбцов.

Освобождение памяти не приводит к ее исчезновению, это просто означает, что другое выделение может захватить тот же кусок памяти. Независимо от того, что вы вставили в него, оно останется там, пока что-то другое не перезапишет его.

Кроме того, вы не освобождаете все, что выделили. Вы освобождаете только массив указателей и первую строку. Но даже если вы освободите все правильно, вы все равно получите тот же эффект.

Если вы хотите создать «ошибку шины», вам нужно указать на память, которая не принадлежит вашему процессу. Почему ты вообще так хочешь?

Я рекомендую использовать valgrind для отслеживания несвободной памяти, вместо того, чтобы пытаться вызвать ошибку шины. Он хорош и для многих других вещей.

Сэм

У вас возникают утечки памяти, потому что вы освобождаете первую строку матрицы и список строк, но ни одну из строк с 1 по n. Вам нужно звонить бесплатно в петлю.

Однако есть несколько альтернатив: - Выделите sizeof (int *) строки + строкиcols * sizeof (int) байтов и используйте первые байты для указателей строк. Таким образом, у вас будет только один фрагмент памяти, который нужно освободить (и это проще для распределителя) - Используйте структуру, содержащую количество строк. Тогда вы можете полностью отказаться от списка строк (экономия памяти). Единственным недостатком является то, что вам нужно использовать функцию, макрос или некоторую беспорядочную нотацию для обращения к матрице.

Если вы выберете второй вариант, вы можете использовать такую ​​структуру в любом компиляторе C99, и снова вам нужно будет выделить только один блок памяти (размером numints * sizeof (int) + sizeof (int)):

struct matrix {
    int rows;
    int data[0];
}

То, что память была освобождена, не означает, что вы не можете получить к ней доступ! Конечно, это идея очень плохой, чтобы получить к нему доступ после того, как он был освобожден, но именно поэтому он работает в вашем примере.

Обратите внимание, что free( *first_matrix ) освобождает только first_matrix[0], а не другие массивы. Возможно, вам понадобится какой-то маркер для обозначения последнего массива (если только вы не всегда будете знать, когда вы освобождаете внешний массив, сколько внутренних массивов вы выделили). Что-то вроде:

int** read_matrix(int size_x, int size_y)
{
    int** matrix;
    matrix = calloc(size_x, 1+sizeof(int*)); // alloc one extra ptr
    for(int i = 0;i<size_x;i++) {
        matrix[i] = calloc(size_y, sizeof(int));
    }
    matrix[size_x] = NULL; // set the extra ptr to NULL
    for(int i = 0;i<size_x;i++) {
        for(int j = 0;j<size_y;j++) {
            matrix[i][j] = i*10+j;
        }
    }
    return matrix;
}

Затем, когда вы их освобождаете:

// keep looping until you find the NULL one
for( int i=0; first_matrix[i] != NULL; i++ ) {
    free( first_matrix[i] );
}
free( first_matrix );

Концепция, которую вам здесь не хватает, заключается в том, что для каждого calloc должен быть бесплатный. и этот free должен быть применен к указателю, возвращаемому из calloc.

Я рекомендую вам создать функцию (с именем delete_matrix) который использует цикл для освобождения всех указателей, которые вы размещаете здесь

for (int i = 0; i <size_x; i ++) { матрица [i] = calloc (size_y, sizeof (int)); }

затем, как только это будет сделано, освободите указатель, выделенный этим.

матрица = calloc (size_x, sizeof (int *));

То, как вы это делаете сейчас,

бесплатно (* first_matrix); бесплатно (first_matrix);

не будет делать то, что вы хотите.