Array subscripting operator [ ]

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. Array bounds are not checked for built-in array types.

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

C++ 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 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];