How to dynamically allocate a 2d array and why? - c

Question

For my assignment one of the things I have to do in my program is dynamically allocate a 2D array.
I can't figure out how to do it or why.
This is what I have now.
size = atoi(argv[1]);
int Pond[size][size];
int i, j;
for(i = 0; i < size; i ++){
for(j = 0; j < size; j++){
Pond[i][j]=0;
}
}
I found a answer to do it this way but I can't figure out how to access each column or row.
int **Pond;
Pond = (int**)malloc(size * sizeof(int*));
for (i = 0; i < size; i++) {
Pond[i] = (int *) malloc(size * sizeof(int));

Answer 1

Correct use of C's powerful array type syntax looks like this:
int (*Pond)[size] = malloc(size * sizeof(*Pond));
That's it for the allocation. After that, the elements in Pond can simply be accessed like this:
for(int y = 0; y < size; y++) {
for(int x = 0; x < size; x++) {
Pond[y][x] = 0;
}
}
And of course the deallocation:
free(Pond);
It doesn't get simpler.

Answer 2

The [] operator works on pointers pretty much the same way it works on array expressions, so you'd use Pond[i][j] to access a particular element regardless of how you allocate (unless you allocated it as a 1D array as dom0 shows).
If the number of rows and columns are known at compile time, this is the easiest:
#define M ... // rows
#define N ... // columns
int (*Pond)[N] = malloc ( sizeof *Pond * M);
...
Pond[i][j] = x;
...
free( Pond );
The type of the variable Pond is "pointer to N-element array of int". The type of the expression *Pond is "N-element array of int". So sizeof *Pond gives us the number of bytes in N-element array of int; we multiply this by M to get the total number of bytes required for the array.
Since a[i] is evaluated as *(a + i), the [] operator works the same way on a pointer expression as it does on an array expression1; that is, you could use Pond[i][j] here as you would for a regular 2D array.
If the number of rows and columns are not known until run time, but you're using a C99 compiler or a C2011 compiler that supports variable length arrays, it's pretty much the same:
size_t n, m;
/**
* get values of n and m
*/
int (*Pond)[n] = malloc( sizeof *Pond * m );
...
Pond[i][j] = x;
...
free( Pond );
Same deal as above, it's just that m and n aren't known until runtime. In both of these cases, the dynamically-allocated arrays are contiguous (all rows are adjacent in memory).
+---+
Pond: | | ---+
+---+ |
... |
+---+ |
Pond[0][0]: | | <--+
+---+
Pond[0][1]: | |
+---+
...
+---+
Pond[0][n-1]: | |
+---+
Pond[1][0]: | |
+---+
Pond[1][1]: | |
+---+
...
+---+
Pond[m-1][0]: | |
+---+
Pond[m-1][1]: | |
+---+
...
+---+
Pond[m-1][n-1]: | |
+---+
If the number of rows and columns aren't known until runtime, and you're using a compiler that does not support VLAs, you have two choices depending on whether you want the arrays to be contiguous or not.
If the array doesn't have to be contiguous, you can use a two-step allocation approach:
size_t n, m;
/**
* get values for n and m
*/
int **Pond = malloc( sizeof *Pond * m ); // allocate m rows of pointer to int
if ( Pond )
{
for ( size_t i = 0; i < m; i++ )
{
Pond[i] = malloc( sizeof *Pond[i] * n ); // allocate n columns of int for each row
}
}
In this case, Pond is a pointer to pointer to int; it will wind up pointing to what is effectively a 1D array of pointers to int; each of those pointers will point to a 1D array of int, sort of like the following:
+---+
Pond: | | ---+
+---+ |
|
+------+
|
V
+---+
Pond[0]: | | ------------+
+---+ |
Pond[1]: | | ---------+ |
+---+ | |
Pond[2]: | | | |
+---+ | |
... | |
+---+ | |
Pond[m-1]: | | | |
+---+ | |
| |
+---+ | |
Pond[0][0]: | | <--------|--+
+---+ |
Pond[0][1]: | | |
+---+ |
... |
+---+ |
Pond[0][n-1]: | | |
+---+ |
|
+---+ |
Pond[1][0]: | | <--------+
+---+
Pond[1][1]: | |
+---+
...
+---+
Pond[1][n-1]: | |
+---+
But because Pond[i][j] is evaluated as *(*(Pond + i) + j), it all still works.
Note that since this was a two-step allocation process, deallocation also requires two steps:
for ( size_t i = 0; i < m; i++ )
free( Pond[i] );
free( Pond );
If the array does need to be contiguous, then you'll have to allocate the memory as a 1D array and compute your indexes manually:
int *Pond = malloc( sizeof *Pond * m * n );
...
Pond[ i * m + j ] = x;
...
free( Pond );
1. Under most circumstances, an array expression will be converted or "decay" to a pointer expression, so the subscript is actually working on a pointer expression either way.