If a 2D array is not a double pointer , then why does this happen?

Question

#include <stdio.h>
int main()
{     
  int arr[3][4] = { 
                    { 10, 11, 12, 13 }, 
                    { 20, 21, 22, 23 }, 
                    { 30, 31, 32, 33 } 
                  }; 
  printf("%u, %u", arr, *arr) // Output - 1875181168, 1875181168

}

Assuming any 2D Array (arr), is not a double pointer, then why does arr & *arr refer to the same address ?

Both the beginning of `arr` and `arr[0]` exist at the same address. Why is that unexpected? — chux - Reinstate Monica, Jul 06 '19 at 02:42
On a side-note, to use `printf` to print (`void *`) pointers, use the `"%p"` format. Mismatching format specifier and argument type leads to *undefined behavior*. — Some programmer dude, Jul 06 '19 at 02:43
@chux - My question was around arr & *arr holding the same value, not around arr pointing to arr[0] — APD, Jul 06 '19 at 02:51
@chux - Sorry, my bad. I meant the relation between arr & arr[0]. arr points to arr[0][0]. — APD, Jul 06 '19 at 03:12

score 8 · Accepted Answer · answered Jul 06 '19 at 02:52

If we "draw" the array arr on paper it will look like this

+-----------+-----------+-----------+-----------+-----------+-----+
| arr[0][0] | arr[0][1] | arr[0][2] | arr[0][3] | arr[1][0] | ... |
+-----------+-----------+-----------+-----------+-----------+-----+

From this it should be easy to see that pointers to the array, the first element of the array, and the first sub-element of the first element will all be the same.

That is, &arr == &arr[0] and &arr[0] == &arr[0][0] (which of course means that &arr == &arr[0][0]).

The differences here is the types:

&arr is of the type int (*)[3][4]
&arr[0] is of the type int (*)[4]
And &arr[0][0] is of the type int *

Now as for arr and *arr, you have to remember that arrays naturally decays to pointers to their first elements. This means arr will be equal to &arr[0]. And dereferencing a pointer will be the "value" being pointed to, so *arr is equal to *(&arr[0]) which is then equal to arr[0] which in turn will decay to &arr[0][0].

If a 2D array is not a double pointer , then why does this happen?

1 Answers1

Linked