(*jmptable[i] ) ()

Similarly, the subscript operator [] is much more flexible in C than most other languages. It requires that one of its operands have an object pointer type (so that excludes pointers to incomplete and function types) and the other have an integer type. It does not require that the name of an array be present. Since subscripting is nothing more than dereferencing an object at some integer offset from a base address, only a base pointer is needed. As a consequence, you may arbitrarily subscript a pointer expression to one level. (Of course, whether the resulting expression produces defined behavior or not, depends on whether you go outside the bounds of the object to which you are pointing.)

The ability to subscript a pointer gives rise to the identity

a[i] is equivalent to *(a + i)

i
i [2]
i [2] [3]
i [2] [3] [4]

Note that the order of the operands of [] is unspecified. That is, a[i] and i [a] are equivalent. This is not to suggest that you should write 2[i] instead of i[2], however, both are valid expressions under K&R as well as ANSI C. Some mainstream compilers will not accept 2[i] and while this in itself is not a big problem, it can make you suspicious about other possible (and illegal) shortcuts the compiler writers may have made. With [] being commutative some other interesting expressions are possible. For example:

a[i] [j] [k]
j[i[a]] [k]
k[j[i[a]]]

The member selection operators --> and . can always be written in terms of each other. For example, s.m is the same as (&s)-->m and ps-->m is equivalent to (*ps).m. The dot operator requires its left operand to designate a structure although not necessarily by name. This makes expressions like f( ).m and (*g( )).m possible.

ANSI C clearly indicates that the postfix versions of ++ and -- have different precedence than their prefix counterparts. Historically, both prefix and postfix versions were combined in the second row. However, this gave rise to problems when faced with expressions such as:

ps++-->m

(ps++)-->m

The unary plus was an ANSI C invention. Originally, it had special grouping semantics but these were removed in a later draft version of the standard. The result of the unary plus operator is the value of its operand. The integral promotion is performed on the operand, and the result has the promoted type.

An expression such as -32768 consists of two source tokens; the unary minus operator and the integer constant 32768. Note there is no such thing as a negative constant in C. The constant is non-negative and it is preceded by a unary minus operator. An interesting situation exists on 16-bit twos-complement machines where -32768 is the smallest value that can be stored in an int. It so happens, that the type of -32768 when written in this form is not int; it's long int, but that's another story.

ANSI C has now made it possible to take the address of an array by using something like &arrayname. Historically, compilers treated this as though you had written &arrayname[0], although some rejected it outright. (For a detailed discussion on pointers to arrays, refer to my column in the May 1990 issue of The C Users Journal.)

In the early days of C, structures and unions were always passed by address just like arrays. However, once structure and union passing by value was introduced, an explicit & was needed to construct the address of a structure. Some compilers issue a warning message if you pass a structure or union by value since they "believe" you might have omitted the & by mistake.

To call a function pointed to by a function pointer, you use the syntax:

(*funptr) (arg-list)

funptr (arg-list)

printf ("Hi there\n");
(*printf) ("Hi there\n");
(**printf) ("Hi there\n");
(***printf) ("Hi there\n");

sizeof expression
sizeof (type)

The cast operator can be used to convert an expression of one type to another with the following restrictions. You cannot cast to or from a structure or union type. You cannot cast to an array or function type. When you cast from an array or function type, the operand is first converted to a pointer. You may cast an expression to its own type and you may also cast an expression to type void. The latter explicitly discards the value of the expression and its use is mostly limited inside function-like macros that replace void functions.

Strictly speaking, the cast operator has precedence lower than the unary operators but higher than the multiplicative operators. However, when shown in tabular form, it is always written along with the unary operators.

ANSI C states that expressions that both associate and commute are still controlled by the precedence table. For example:

a * b * c

(a * b) * c

In the early days of C, the compound assignment operators were written in the reverse order. For example, += and >>= were written as =+ and =>>, respectively. Unfortunately, this causes problems with expressions like i =-5. While you probably wanted to assign -5 to i, you were, in fact, subtracting 5 from the current value of i. These old operators were declared archaic in the first edition of K&R and are only supported by a handful of mainstream compilers. They are not part of ANSI C.

The comma operator is rather special and powerful and is discussed in my columns in the August 1988 and the November 1989 issues of CUJ. It is typically used only inside macros or in the first and third expressions of a for construct.

Only four operators are able to produce an lvalue expression. They are: *, [], ->, and dot. (For a detailed discussion on lvalues, refer to my column in the August 1989 issue.)