How does subtracting an address reference work?

I think the value of z should be 40 because a[5] has 20 elements, and the space between it and a[3] also has 20 elements. However, the actual value of z is 2.

Can anyone explain this concept?

#include <stdio.h>

int main()
{
    int a[10][20];
    int z = &a[5] - &a[3];
    printf("%d\n", &a[3]); // the address information is 6421740
    printf("%d\n", &a[5]); // the address information is 6421900
    printf("%d\n", z);     // z value is 2. why?
}

Pointer arithmetic is done in the units of the pointed-to type.

In this case a[5] and a[3] are both elements of an array of type int [20], and &a[5] and &a[3] both have type int(*)[20]. They are 2 array element apart, so the difference between them is 2.

It doesn't matter that the underlying type is also an array.

> and the space between it and a[4] also has 20 elements

No, the element of a[4] has the type of array of 20 ints. It is not an int.

It is called pointer arithmetics. It does not work on bytes or chars only on the type of pointer.

&a[3] has type of pointer to int[20]. &a[5] has type of pointer to int[20] and it located two (2) int[20] arrays from &a[3].

It is much easier to explain using a simpler example.

int main(void)
{
    double dbl[10];
    for(size_t i = 0; i < 10; i++ )
    {
        size_t distance = (dbl + i) - dbl;
        size_t distancebytes = (char *)(dbl + i) - (char *)dbl;
        printf("dbl + %zu is %zu double and %zu bytes from dbl\n", i, distance, distancebytes);
    }
}

dbl + 0 is 0 double and 0 bytes from dbl
dbl + 1 is 1 double and 8 bytes from dbl
dbl + 2 is 2 double and 16 bytes from dbl
dbl + 3 is 3 double and 24 bytes from dbl
dbl + 4 is 4 double and 32 bytes from dbl
dbl + 5 is 5 double and 40 bytes from dbl
dbl + 6 is 6 double and 48 bytes from dbl
dbl + 7 is 7 double and 56 bytes from dbl
dbl + 8 is 8 double and 64 bytes from dbl
dbl + 9 is 9 double and 72 bytes from dbl

https://godbolt.org/z/KoKn8sM5b

According to the C Standard (6.5.2.1 Array subscripting)

> 2 A postfix expression followed by an expression in square brackets []
> is a subscripted designation of an element of an array object. The
> definition of the subscript operator [] is that E1[E2] is identical to
> (*((E1)+(E2))). Because of the conversion rules that apply to the
> binary + operator, if E1 is an array object (equivalently, a pointer
> to the initial element of an array object) and E2 is an integer,
> E1[E2] designates the E2-th element of E1 (counting from zero).

So the expression a[3] is evaluated like *( a + 3 ). As a result the expression &a[3] is equivalent to the expression &*( a + 3 ) that in turn is equivalent to ( a + 3 ).

The same way the expression &a[5] is equivalent to the expression ( a + 5 ).

So the difference &a[5] - &a[3] is evaluated like ( a + 5 ) - ( a + 3 ) that yields 2. That is between these two addresses &a[5] and &a[3] there are only two elements of the type int[20].

On the other hand if you would write ( int * )&a[5] - ( int * )&a[3] that is if the array would be interpreted as a one-dimensional array of the type int you would get 2 * 20 that yields the expected by you value 40.