Title: Reading C & C++ Variable Declarations

I was never formally taught the C language. In college in 1979 the main teaching language was Pascal. I learnt C by looking over the shoulders of more knowledgeable colleagues in my first job. By studying their program listings it was fairly obvious that int i; declared that i was an integer, that char *cp; declared a pointer to a character and that char buf[100]; declared an array of 100 characters. I soon came to understand that char *argv[] was an array of pointers to characters. But that was about as far as I got. I found more complex declarations puzzling. I was reminded of this recently while reading an interview with Bjarne Stroustrup [Stroustrup2000]:

I find the fact that Stroustrup finds declarations difficult to get right somewhat reassuring. I, too, use his technique of breaking complex declarations down into more manageable stages using typedefs. I think his example is a good one: I can grasp the declaration of p using typdefs much quicker than I can understand the one line declaration. And I could not have understood the latter at all before I learnt the "Right-Left" rule, more on which in a moment.

If you want to really understand C declarations I suggest the best place look is section A8 of The C Programming Language [KandR1988], from which the above quote is taken. There you will find a dozen pages describing the syntax and meaning of declarations. For a concise summary I would turn to section 4.9.1 of The C++ Programming Language [Stroustrup1997], from which the following extract is taken:

Here, the base type is char, the declarator is *kings[], and the initializer is ={…}.

A specifier is an initial keyword, such as virtual and extern, that specifies some non-type attribute of what is being declared.

A declarator is composed of a name and optionally some declarator operators. The most common declarator operators are:

Their use would be simple if they were all either prefix or postfix. However, *, [], and () were designed to mirror their use in expressions. Thus, * is prefix and [] and () are postfix. The postfix declarator operators bind tighter than the prefix ones. Consequently, *kings[] is a vector of pointers to something, and we have to use parentheses to express types such as "pointer to function."

So to turn Stroustrup's kings declarator example from a vector (array) of pointers to something into a pointer to a vector of something we would use parentheses like so: (*kings)[]. It is this mixture of pre- and postfix operators where the Right-Left rule can help.

The rule is described in various places on the web, which is where I first came across it. But I do not know who first coined the term. The Right-Left rule for reading declarations is:

Repeat rules 2 and 3 until there are no more operators to interpret.

Using this rule to work through the example Stroustrup quotes in the above interview:

bool (*(*p)[10])(int, int);

Rule 1, locate the identifier: "p is"

bool (*(*p)[10])(int, int);

Rule 2, go right, encounter right parentheses, go left.

bool (*(*p)[10])(int, int);

Rule 3, go left, encounter *, look up in table: "p is pointer to"

bool (*(*p)[10])(int, int);

Rule 3, go left, encounter left parentheses, go right.

bool (*(*p)[10])(int, int);

Rule 2, go right, encounter [10], look up in table: "p is pointer to array of 10"

bool (*(*p)[10])(int, int);

Rule 2, go right, encounter right parentheses, go left.

bool (*(*p)[10])(int, int);

Rule 3, go left, encounter *, look up in table: "p is pointer to array of 10 pointers to"

bool (*(*p)[10])(int, int);

Rule 3, go left, encounter left parentheses, go right.

bool (*(*p)[10])(int, int);

Rule 2, go right, encounter (int, int), look up in table: "p is pointer to array of 10 pointers to function taking args "int, int" and returning"

bool (*(*p)[10])(int, int);

Rule 2, go right, no more operators, go left.

bool (*(*p)[10])(int,int);

Rule 3, go left, and encounter base type: "p is pointer to array of 10 pointers to function taking args "int, int" and returning bool"

As you can see, this simple mechanical process has produced a fairly clear description of the given declaration. It is worth noting that just because you can use the Right-Left rule to turn a declaration into English, it isn't necessarily legal C. For example, the Right-Left rule will merrily read

int (*fn)()[7];

as "fn is a pointer to a function returning array of 7 ints," which, as you know, is not permitted in C.

Not everyone will find this mechanical approach to reading declarations necessary or useful. But personally I do. Some years ago I saw a program that, given a C declaration, would spit out the equivalent English description. I thought this was quite magic at the time, but now I can see it would not be too hard to encode the Right-Left rule.