A distinctive syntactic peculiarity of C is that declarations mirror the use of the declared object as it would be in a normal expression.
The following set of operators with identical precedence and associativity are reused in declarators, namely:
- the unary * "dereference" operator which denotes a pointer;
- the binary  "array subscription" operator which denotes an array; the (1+n)-ary
- () "function call" operator which denotes a function;
- the () grouping parentheses which override the precedence and associativity of the rest of the listed operators.
The above three operators have the following precedence and associativity:
Operator Relative Precedence Associativity
 (array subscription) 1 Left-to-right
() (function call)
When interpreting declarations, one has to start from the identiﬁer outwards and apply the adjacent operators in the correct order as per the above table. Each application of an operator can be substituted with the following English words:
thing[X] an array of size X of...
thing(t1, t2, t3) a function taking t1, t2, t3 and returning...
*thing a pointer to...
It follows that the beginning of the English interpretation will always start with the identiﬁer and will end with the type that stands on the left-hand side of the declaration.
 takes precedence over *, so the interpretation is: names is an array of size 20 of a pointer to char.
In case of using parentheses to override the precedence, the * is applied ﬁrst: place is a pointer to an array of size 10 of char.
int fn(long, short);
There is no precedence to worry about here: fn is a function taking long, short and returning int.
The () is applied ﬁrst: fn is a function taking void and returning a pointer to int.
Overriding the precedence of (): fp is a pointer to a function taking void and returning int.
Multidimensional arrays are not an exception to the rule; the  operators are applied in left-to-right order according to the associativity in the table: arr is an array of size 5 of an array of size 8 of int.
The two dereference operators have equal precedence, so the associativity takes eﬀect. The operators are applied in right-to-left order: ptr is a pointer to a pointer to an int.
The comma can be used as a separator (*not* acting like the comma operator) in order to delimit multiple declarations within a single statement. The following statement contains ﬁve declarations:
int fn(void), *ptr, (*fp)(int), arr, num;
The declared objects in the above example are:
- fn: a function taking void and returning int;
- ptr: a pointer to an int;
- fp: a pointer to a function taking int and returning int;
- arr: an array of size 10 of an array of size 20 of int;
- num: int.
Because declarations mirror use, a declaration can also be interpreted in terms of the operators that could be applied over the object and the ﬁnal resulting type of that expression. The type that stands on the left-hand side is the ﬁnal result that is yielded after applying all operators.
* Subscripting "arr" and dereferencing it yields a "char" result.
* Particularly: *arr is of type "char".
* Calling "fn" yields an "int" result.
* Particularly: fn('b') is of type "int".
* Dereferencing "fp" and then calling it yields an "int" result.
* Particularly: (*fp)() is of type "int".
* Subscripting "strings" twice and dereferencing it yields a "char" result.
* Particularly: *strings is of type "char"