Как правильно выделить место в двумерном массиве, избегая при этом повреждения памяти?

несколько проблем в вашем коде

a = (int **)malloc(sizeof(int *));

должно быть

a = (int **)malloc(sizeof(int *)*cats); /* size for cats pointers rather than just 1 */

а также

for (i=0; i<cats; i++)
   for (j=0; j<loops; j++) {
       a[i] = (int *)malloc(sizeof(int));
       a[i][j] = i+j;
   }

должно быть

for (i=0; i<cats; i++) { /* '{' added */
    a[i] = (int *)malloc(sizeof(int) * loops); /* moved and loops int rather than 1 */
    for (j=0; j<loops; j++) {
        a[i][j] = i+j;
    }
} /* '}' added */

С этим исправлением компиляция и выполнение под валгринд :

pi@raspberrypi:/tmp $ gcc -g -pedantic -Wextra -Wall c.c
pi@raspberrypi:/tmp $ valgrind ./a.out
==5795== Memcheck, a memory error detector
==5795== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==5795== Using Valgrind-3.13.0 and LibVEX; rerun with -h for copyright info
==5795== Command: ./a.out
==5795== 
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 
==5795== 
==5795== HEAP SUMMARY:
==5795==     in use at exit: 372 bytes in 4 blocks
==5795==   total heap usage: 5 allocs, 1 frees, 1,396 bytes allocated
==5795== 
==5795== LEAK SUMMARY:
==5795==    definitely lost: 12 bytes in 1 blocks
==5795==    indirectly lost: 360 bytes in 3 blocks
==5795==      possibly lost: 0 bytes in 0 blocks
==5795==    still reachable: 0 bytes in 0 blocks
==5795==         suppressed: 0 bytes in 0 blocks
==5795== Rerun with --leak-check=full to see details of leaked memory
==5795== 
==5795== For counts of detected and suppressed errors, rerun with: -v
==5795== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 6 from 3)
p

конечно у тебя утечки памяти

a = (int **)malloc(sizeof(int *)); динамически выделяет место для указателя один и возвращает указатель на него. Вы не можете получить доступ к a[i] для любого i > 0, потому что он выйдет за пределы. Чтобы выделить место для нескольких указателей, вам нужно передать соответствующий размер в malloc.

Либо...

a = malloc(sizeof*a * cats);

... или...

a = malloc(sizeof (int*[cats]));

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

int (*a)[loops] = malloc(sizeof (int[cats][loops]));

Меньше выделений означает меньше шансов ошибиться.

Существуют разные способы размещения 2D-матрицы int:

• Вы можете выделить массив массивов int.

• Вы можете выделить массив указателей на массивы int и выделить разные массивы int для каждого из этих указателей. Это то, что вы пробовали, но размеры выделения неверны.

массив указателей на массивы int должен иметь размер cats * sizeof(int *). и каждый массив int должен быть размещен во внешнем цикле размером loops * sizeof(int), а не во внутреннем цикле, как вы это сделали.

Кроме того, вы должны освободить эти объекты перед выходом из программы, чтобы Valgrind мог видеть чистую пластину.

Вот исправленная версия:

#include <stdio.h>
#include <stdlib.h> 

#define cats 3
#define loops 30

int main() {
    int **a;
    int i, j;

    a = malloc(cats * sizeof(int *));

    for (i = 0; i < cats; i++) {
        a[i] = malloc(loops * sizeof(int));
        for (j = 0; j < loops; j++) {
            a[i][j] = i + j;
        }
    }

    for (i = 0; i < cats; i++) {
        for (j = 0; j < loops; j++)
            printf("%d ", a[i][j]);
        printf("\n");
    }

    for (i = 0; i < cats; i++)
        free(a[i]);
    free(a);

    return 0;
}

Этот стиль непрямая 2D-матрица обычно осуждается, потому что:

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

Есть некоторые преимущества, ни один из которых здесь не нужен:

• можно не выделять некоторые строки
• можно разделить одинаковые строки (за счет усложнения освобождения)
• линии могут иметь разный размер, но это уже не матрица
• линии могут быть заменены местами эффективно.

Другой подход, который считается единственным реальным 2D-матрица, использует одно выделение и несколько менее очевидный тип для указателя матрицы:

    int (*a)[loops] = malloc(sizeof(int) * loops * cats);

Что можно написать:

    int (*a)[loops] = malloc(sizeof(*a) * cats);

Или, возможно, более читаемо:

    int (*a)[loops] = malloc(sizeof(int[cats][loops]));

a указывает на массив cats массивов loopsint.

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

Вот упрощенная версия вашей программы с таким подходом:

#include <stdio.h>
#include <stdlib.h> 

#define cats 3
#define loops 30

int main() {
    int (*a)[loops] = malloc(sizeof(*a) * loops);

    if (a != NULL) {
        for (i = 0; i < cats; i++) {
            for (j = 0; j < loops; j++)
                a[i][j] = i + j;
        }
        for (i = 0; i < cats; i++) {
            for (j = 0; j < loops; j++)
                printf("%d ", a[i][j]);
            printf("\n");
        }
        free(a);
    }
    return 0;
}