How do dynamic two dimensional arrays actually work in C?

How do dynamic two dimensional arrays actually work in C?

When we create a two- dimensional array via heap, all we need is an array of pointers :

const int N = 4;
int** p = calloc(N, sizeof(int*));

All this code does is reserve memory for an array of 4 elements and initializes the memory in 0. Each element is a pointer and its size in bytes will depend on whether the machine is 32-bit or 64-bit.

On a 32-bit machine the expression sizeof(int*)would result in 4bytes (that would be the size of the pointer) and on a 64-bit machine the size would be 8bytes.

Visually we would see it like this:

Here it is clear that the pointer pis pointing to the address 0x016(it is the base address of the array ).

Then we must make each element of the array of pointers point to the base address of an array, which can be an array of int, of char, etc.

In this case it should be an array of integers:

const int N = 4;
const int M = 3;
int** p = calloc(N, sizeof(int*));
for(int i = 0; i != N; ++i)
{
    p[i] = malloc(M * sizeof(int));
    for(int j = 0; j != M; ++j)
        p[i][j] = rand() % 10;
}

This code does 2 things:

1.- It creates an array intdynamically and assigns it the base address in Xthe position of the array of pointers.

2.- Fill with values ​​each position of the array to which each pointer points.

Visually we would see it like this:

In the image you can clearly see that each pointer points to the first element of an array.

In these two images we can observe two important things:

1.- The array of pointers is contiguous (its elements are together).

2.- Each pointer points to a contiguous array. However, each array of integers are not contiguous with each other, so there will be gaps around them.

We could visualize the heap in this way (click on the image to see it better):

In the image we can observe three things:

1.- Each array is actually like a kind of memory block.

2.- The elements of each block are contiguous.

3.- The memory blocks (or the arrays ) are not contiguous with each other, there are gaps around them.

Understanding how the two- dimensional array is reflected in memory, we could answer these questions:

What I say again, is correct?

You are all correct. The rows are like the array of pointers and each array that the pointer points to is like the columns and that's how you create a kind of "array".

And yes, through the pointers is how you can access each of those arrays. You basically already had the answer.

Is this correct?

Yes you are correct. A pointer will simply contain the memory address of the first element of the array . With this saved address, an offset is added to be able to reach the memory address that you want to read or write.

Do all arrays end with \0 or is this something unique to character arrays?

No. In C, only character arrays need to end with the null character and this is because in order to traverse the entire array you need to have a beginning and an end (the null character will indicate the end).

Continuing with the doubts, when assigning dynamic memory to a pointer. What really happens?

This example shows how it works:

int* p = malloc(5* sizeof(int));

Two things happen here:

1.- The function mallocmakes a call to the operating system so that it assigns to the current process (that is, to the program that is being executed) a block of 24 bytes ( 5 * sizeof(int)).

2.- When the system allocates the memory, the function will mallocreturn the base address of said block and in this way, by means of the pointer pit will be possible to access any position of the reserved block.

Again, is this correct?

No. The compiler is not in charge of allocating dynamic memory, but functions like malloc, callocor realloc.

If there is no memory available, these functions will return NULL.