A postfix expression followed by an expression in `[ ]` (brackets)
specifies an element of an array. The expression within the brackets is referred
to as a subscript. The first element of an array has
the subscript zero.

By definition, the expression `a[b]` is equivalent to the expression `*((a) + (b))`, and, because addition is associative, it is also equivalent
to `b[a]`. Between expressions `a` and `b`, one
must be a pointer to a type `T`, and the other must have integral
or enumeration type. The result of an array subscript is an lvalue. The following
example demonstrates this:

#include <stdio.h> int main(void) { int a[3] = { 10, 20, 30 }; printf("a[0] = %d\n", a[0]); printf("a[1] = %d\n", 1[a]); printf("a[2] = %d\n", *(2 + a)); return 0; }

The following is the output of the above example:

a[0] = 10 a[1] = 20 a[2] = 30

The above restrictions on the types of expressions required
by the subscript operator, as well as the relationship between the subscript
operator and pointer arithmetic, do not apply if you overload `operator[]` of a class.

The first element of each array has the subscript `0`. The expression `contract[35]` refers to the 36th element in the array `contract`.

In a multidimensional array, you can reference each element (in the order of increasing storage locations) by incrementing the right-most subscript most frequently.

For example, the following statement gives the value `100` to
each element in the array `code[4][3][6]`:

for (first = 0; first < 4; ++first) { for (second = 0; second < 3; ++second) { for (third = 0; third < 6; ++third) { code[first][second][third] = 100; } } }

C only

C99 allows array subscripting on arrays that are not lvalues. However, using the address of a non-lvalue as an array subscript is still not allowed. The following example is valid in C99:

struct trio{int a[3];}; struct trio f(); foo (int index) { return f().a[index]; }

End of C only

Related information