The clean way to refer to an array element is
array[index]. Another, complicated way to do the
same job is to get the address of that element as a pointer, then
* (&array + index) (or
* (array + index)). This first gets a
pointer to element zero, then increments it with
+ to point to
the desired element, then gets the value from there.
That pointer-arithmetic construct is the definition of square
brackets in C.
a[b] means, by definition,
*(a + b). This definition uses a and b
symmetrically, so one must be a pointer and the other an integer; it
does not matter which comes first.
Since indexing with square brackets is defined in terms of addition
and dereference, that too is symmetrical. Thus, you can write
3[array] and it is equivalent to
array. However, it
would be foolish to write
3[array], since it has no advantage
and could confuse people who read the code.
It may seem like a discrepancy that the definition
b) requires a pointer, but
array uses an array value
instead. Why is this valid? The name of the array, when used by
itself as an expression (other than in
sizeof), stands for a
pointer to the arrays’s zeroth element. Thus,
array + 3
array implicitly to
&array, and the result
is a pointer to element 3, equivalent to
Since square brackets are defined in terms of such addition,
array first converts
array to a pointer. That’s why
it works to use an array directly in that construct.