Question

I yesterday came across a question on SO, that wanted to dynamically allocate a 2-D array in C.

One of the answers was to allocate it this way:

int (*place)[columns] = malloc(rows * sizeof *place);

This apart from being beautiful, brought a question to my head. The question goes below:

Following is the code in which i allocate a 4×4

    int (*arr)[4] = (int (*)[4]) malloc(4 * sizeof *arr);
    printf("%d\n", sizeof arr);                 //Dynamic 2-D array by above method
    
    int **arr1 = (int**) malloc(4 * sizeof(int*));
    for(int i = 0; i < 4; i++)
            arr1[i] = (int *) malloc(sizeof(double));
    printf("%d\n", sizeof arr1);                          //Usual dynamic 2-D array

    int *arr2 = (int*) malloc(4 * sizeof(int));
    printf("%d\n", sizeof arr2);                          //Dynamic 1-D array
    
    

The usual output is:

4
4
4

However, if i try to print sizeof *arr, sizeof *arr1 and sizeof *arr2, the output is:

16
4
4

I don’t understand why this is happening. Any idea why the output for sizeof *arr is 16? How is the memory being being allocated in the first case?

Also, when i try to print the address of arr and *arr, both the printed values are same. *arr means "value at" arr. So does that mean arr stores its own address, i.e., it is pointing to itself (which i don’t think is possible)? Am slightly confused. Any idea where am I going wrong?

Thanks for your help!

Answer 1

However, if I try to print sizeof *arr, sizeof *arr1 and sizeof *arr2, I get 16, 4, and 4.

where:

int (*arr)[4];
int **arr1;
int *arr2;

You must be working on a 32-bit machine, not a 64-bit machine.

The type of arr is ‘pointer to an array of 4 int‘. When you dereference it, you get an ‘array of 4 int‘. When passed to sizeof, the array is of size 16 (4 * sizeof(int)). Most of the time, when you reference an array, the type is adjusted to ‘pointer to zeroth element of the array’, but sizeof() is the primary exception to that rule; it sees an array as an array and returns the size of the whole array.

The type of arr1 is ‘pointer to pointer to int‘. When you dereference it, you get a ‘pointer to int‘. When passed to sizeof, the pointer is of size 4 (sizeof(int *)).

The type of arr2 is ‘pointer to int‘. When you dereference it, you get an int. When passed to sizeof, the int is of size 4.

---

Okay! I get most of it. But … why isn’t the output 16 when I do sizeof arr2?

As James noted in his comment:

because sizeof(arr2) reduces to sizeof(int*) which on a 32-bit machine is 4.

That is, arr2 is a pointer; the size of a pointer is 4 on a 32-bit machine.

Also, arr is a ‘pointer to an array of 4 int’, i.e., a single pointer. Then how do I get a 4×4 matrix.

You can use either of these:

int mat1[4][4];
int (*mat2)[4][4];

The first is a straight-forward 4×4 matrix. The result of sizeof(mat1) will be 64 on a 32-bit machine (and most 64-bit machines, as it happens).

The second is a pointer to a 4×4 matrix of int. The result of sizeof(mat2) will be 4 on a 32-bit machine; mat2 is a pointer (to a 4×4 matrix of int), so it is of size 4, the same as every other object pointer (and, in practice, the same size as every function pointer, though the C standard does not guarantee that function pointers and object pointers are the same size; POSIX does guarantee that, though).

The result of sizeof(*mat2) is the size of the object that mat2 points at, which is a 4×4 matrix of int, so the size is 64 again.