C multidimensional arrays and dereferencing array pointers

You're thinking too low-level. Your question pertains to variable names and types (at the language level).

When you declare int zippo[4][2] = {{2, 4}, {6, 8}, {1, 3}, {5, 7}};, you end up with an array of four arrays of two ints. They can be accessed in many ways, depending on what you need to express. Here are some of the sub-objects involved:

| 2 | 4 | 6 | 8 | 1 | 3 | 5 | 7 |    The storage for zippo: 8 contiguous ints

|<--+---+---+---+---+---+---+-->|    zippo (the whole array), is an int[4][2]
|<--+-->|                            zippo[0] (also known as *zippo) is an int[2]
                |<--+-->|            zippo[2] is also an int[2]
|<->|                                zippo[0][0] (also known as **zippo) is an int
            |<->|                    zippo[1][1] is also an int

You can see that these sub-objects can overlap, and in some case share addresses. What still makes them distincts objects (for you, the language, and the compiler) is their type.

For example, zippo[0] and zippo[0][0] (which is its first half) have the same address, but one of them is an int, while the other is an array of two ints.

That is why you can't keep indexing into zippo[0][0], or try to use zippo[0] inside an integer calculation: even though they share the same storage, they're different objects with different meanings.

And even though indexing into arrays involves pointer arithmetic, there is no actual chain of pointers, no int*** that your first understanding implies. It's all variable names.

No *zippo do not go to location 15 then find the value at this location. If it was so then printf(" * ((int **) zippo) = %p\n", * ((int **) zippo) ); would output the same thing as printf(" *zippo = %p\n", *zippo); and that is not the case.

When I run this code this is what I obtain :

#include <stdio.h>

int zippo[4][2] = {{2, 4}, {6, 8}, {1, 3}, {5, 7}};

int main(){
    printf("zippo[0] = %p\n", (void *) (zippo[0]) );
    printf("  zippo = %p\n", (void *) zippo);
    printf("  *zippo = %p\n", (void *) (*zippo) );
    printf("  **zippo = %d\n", (int) ( **zippo) );
    printf("  * ((int **) zippo)  = %p\n", (void *) (* ((int **) zippo) ));
}

This is what I obtain :

zippo = 0x804a040
*zippo = 0x804a040
**zippo = 2
* ((int **) zippo)  = 0x2

I compiled this code using gcc -Wall -Wextra -Wpedantic -pedantic to ensure that no warning is hidden and the option -m32 to have 32 bits adresses (same size as int).

I actually had a hard time understanding what is happening in there so I decided to have a look at the corresponding assembly code. using gcc -S file.c -o file.s I obtain the following.

First variable declaration :

    .globl  zippo
    .data
    .align 32
    .type   zippo, @object
    .size   zippo, 32
zippo:
    .long   2
    .long   4
    .long   6
    .long   8
    .long   1
    .long   3
    .long   5
    .long   7
    .section    .rodata
.LC0:
    .string "zippo[0] = %p\n"
.LC1:
    .string "  zippo = %p\n"
.LC2:
    .string "  *zippo = %p\n"
.LC3:
    .string "  **zippo = %d\n"
.LC4:
    .string "  * ((int **) zippo)  = %p\n"

The correcsponding assembly for printf("zippo[0] = %p\n", (void *) (zippo[0]) ); :

movl    $zippo, %esi
movl    $.LC0, %edi
movl    $0, %eax
call    printf

The correcsponding assembly for printf(" zippo = %p\n", (void *) zippo); :

movl    $zippo, %esi
movl    $.LC1, %edi
movl    $0, %eax
call    printf

The correcsponding assembly for printf(" *zippo = %p\n", (void *) (*zippo) );

movl    $zippo, %esi
movl    $.LC2, %edi
movl    $0, %eax
call    printf

The correcsponding assembly for printf(" **zippo = %d\n", (int) ( **zippo) ); :

movl    $zippo, %eax
movl    (%rax), %eax
movl    %eax, %esi
movl    $.LC3, %edi
movl    $0, %eax
call    printf

The correcsponding assembly for printf(" * ((int **) zippo) = %p\n", (void *) (* ((int **) zippo) ));

movl    $zippo, %eax
movq    (%rax), %rax
movq    %rax, %rsi
movl    $.LC4, %edi
movl    $0, %eax
call    printf

As you can notice here, for the 3 first printf, the corresponding assembly is exactely the same (what changes is LCx which corresponds to format). Same thing for the last 2 printf.

My understanding is that as the compiler is aware that zippo is a 2 dimensional array, and therefore knows that *zippo is 1 dimensional array whose data starts at the adress of the first element.

Although it looks like if the memory address of zippo is 30 and the value of zippo and *zippo is 15 is happening, it is not happening. Think in terms of data types. Take a super dimensional array.

int zappo[2][3][4][5][6] = {{{{{45,55,66,77,88,99},{12,22,32....

When you define a variable like this (on the stack, not using chained malloc) the compiler does not allocate one value zappo, another for *zappo and another for **zappo etc. It writes 45,55,66,77,88,99,12,22,32 in a contiguous block of memory, say at 0xfe. Now at compile time, it knows that

zappo is a pointer, and has a value 0xfe
*zappo is a pointer, and has a value 0xfe
**zappo is a pointer, and has a value 0xfe
***zappo is a pointer, and has a value 0xfe
****zappo is a pointer, and has a value 0xfe
*****zappo is a pointer, and has a value 0xfe, but this one points to an int!

The compiler thinks in terms of data type. So only the last dereference results in an int, the rest, to just one address. This is not the same as declaring

int *****zappo;

and painstakingly creating the array structure manually (in the heap, with some alloc). That's where you can use your box analogy.