Question

I am trying to increase the size of my 2D array and hm is a struct that contains the x length of the array. I am using value -99999991 to indicate the end of the array.

Is this the correct way to do it?

 hm->value = realloc(hm->value,(hm->x+1)*sizeof(int));
            hm->value[hm->x] = malloc(sizeof(int));
            hm->value[hm->x][0] = -999999991;
            hm->value[hm->x-1] = realloc(hm->value[hm->x-1],2*sizeof(int));
            hm->value[hm->x-1][1] = -999999991;
            hm->value[hm->x-1][0] = value;

Answer 1

You don’t have a 2D array if it can be resized, you have a pointer to a pointer to an int.

An array:

int A[n][m];
Accessing the array: A[2][3] = 4; // Equivalent to *(A + 2*m + 3)

A variable sized 2D “array”:

int **A;
A = malloc(n*m*sizeof(int));
A[2][3] = 4; // Equivalent to *A + 2*??? + 3)

The compiler doesn’t know if your array is one dimensional, or if it is two dimensional then what the size of the two dimensions are. It can’t calculate this any more.
Also, realloc can’t put the data in the right place. Consider a 2×2 2D array going to a 2×3 2D array:

int **A = {{0,1}, {2,3}}; // for berevity - this isn't valid C!
// stored in memory as [0,1,2,3]
A = realloc(A, 2*3* sizeof(int));

New array stored in memory is [0,1, , 2, 3, ]; This required copying the data.

There are two decent solutions (though they aren’t pretty):
1) Treat your 2D array as a list of 1D arrays

int **A;
A = malloc(m*sizeof(void *));
for (i = 0; i < m; ++i) {
    A[i] = malloc (n*sizeof(int);
}

(now realloc should work on both of these arrays, but accessing elements will require two pointer dereferences rather than pointer arithmetic)

2) if one of the dimensions of the array is fixed then we can use a 2D array in memory and realloc it as required.

#define M 16
int **A;
A = malloc(M*n*sizeof(int)); // realloc also works
// access an element:
*(A + 3*M + 2) = 4; // (3*M is compile time constant)

In this second example we always grow at the end of our 2D array (so my example of going from 2×2 to 2×3 is illegal – the second 2 is a fixed length).