Complex declarations

Solution 1:

Here is a great article about how to read complex declarations in C: http://www.codeproject.com/KB/cpp/complex_declarations.aspx

It helped me a lot!

Especially - You should read "The right rule" section. Here quote:

int * (* (*fp1) (int) ) [10]; This can be interpreted as follows:

1. Start from the variable name -------------------------- fp1
2. Nothing to right but ) so go left to find * -------------- is a pointer
3. Jump out of parentheses and encounter (int) --------- to a function that takes an int as argument
4. Go left, find * ---------------------------------------- and returns a pointer
5. Jump put of parentheses, go right and hit [10] -------- to an array of 10
6. Go left find * ----------------------------------------- pointers to
7. Go left again, find int -------------------------------- ints.

Solution 2:

You can use cdecl*:

cdecl> explain int *( *( *a[5])())();
 declare a as array 5 of pointer to function
 returning pointer to function returning pointer to int
cdecl> explain int * (* (*fp1) (int) ) [10];
 declare fp1 as pointer to function (int) returning
 pointer to array 10 of pointer to int

*Linked is a website that uses this command line tool in the backend.

Solution 3:

I've learned the following method long ago:

Start from the type identifier (or the inner parenthesis) and move following a spiral taking the element at right first

In case of

 int * (* (*fp1) (int) ) [10];

You can say:

• fp1 is a (nothing on the right so move left)
• pointer to (move out of the inner parenthesis
• a function taking int as agument (the 1st on the right)
• and returns a pointer to (exit from parenthesis)
• an array of 10 elements of type
• pointer to (nothing left on the right)
• int

Resulting in:

fp1 is a pointer to a function taking an int and returning a pointer to an array of 10 pointers to int

Drawing the actual spiral (in you your mind, at least) helps a lot.

Solution 4:

For solving these complicated declarations, the rule you need to keep in mind is that the precedence of function-call operator () and array subscript operator [] is higher than dereference operator *. Obviously, parenthesis ( ) can be used to override these precedences.

Now, work out your declaration from the middle, which means from the identifier name.

int * (* (*fp1) (int) ) [10]; --->declaration 1

Based on the precedences rule mentioned above, you can easily understand it by breaking down the declaration as

fp1 * (int) * [10] * int

and read it directly from left-to-right in English as "fp1 is a pointer to a function accepting an int & returning a pointer to an array [10] of pointers to int". Note that the declaration is broken this way only to help understand it manually. The compiler need NOT parse it this way.

Similarly,

int *( *( *[5])())(); -------->declaration 2

is broken as

[5] * () * () * int

So, it declares "an array [5] of type pointers to function () which returns a pointer to a function () which in turn returns a pointer to int".