Get confused with this declaration - int ((foo)(double))[3]

Question

I am lost in this declaration - int (*(*foo)(double))[3];

My understanding is that this is an array with size 3 which element is a function pointer taking double and returning pointer to int. However, the correct explanation seems to be "pointer to function taking double and returning pointer to array of 3 int". The returning pointer to array of 3 int confuses me a lot as int and [3] far apart.

Why is that? What is the syntax or rule to declare variables like this complex?

See: http://stackoverflow.com/questions/3706704/whats-the-meaning-of-this-piece-of-code-void-signalint-sig-void-funcin/3706735#3706735 for some guides in the answers. — CB Bailey, Jan 01 '14 at 14:52
@user2485710 They already have the correct answer. They want to know why. — Joseph Mansfield, Jan 01 '14 at 14:54
The part confused me is that how [3] in this declaration will be interpreted. — Wayne Wang, Jan 01 '14 at 15:01
Well, `int` and `[3]` aren't that far apart if you consider the bit in parentheses as one "thing". `int a[3];` vs `int (...)[3];`. — CB Bailey, Jan 01 '14 at 15:10
I like to use typedefs to break a declaration like this apart. That doesn't help if you inherited the code though. — Mark Ransom, Jan 01 '14 at 15:36
@MarkRansom I seriously doubt you'd find this kind of declaration in real world code. It's practically unmaintainable. My best guess is that this is some kind of homework question. — fredoverflow, Jan 01 '14 at 17:16
@FredOverflow you'd be amazed to discover what you can find in the real world. You're probably right though. — Mark Ransom, Jan 01 '14 at 17:41
@MarkRansom And you're *definitely* right about the `typedef`s :) — fredoverflow, Jan 01 '14 at 18:03

score 8 · Accepted Answer · answered Jan 01 '14 at 15:15

You just read from the inside out remembering that postfix array ([]) and function "call" (()) bind tighter than prefix pointer (*):

      (*foo)              // foo is a pointer...
      (*foo)(double)      // to a function taking a double...
    (*(*foo)(double))     // returning a pointer...
    (*(*foo)(double))[3]  // to an array of 3...
int (*(*foo)(double))[3]; // ints

(To work out where to start you might want to work from the outside in, but you need to read back from the inside out to read the declaration in the conventional order.)

score 5 · Answer 2 · answered Jan 01 '14 at 15:15

You can use "clockwise spiral rule"

      +----------------------------------+
      |  +---------------------------+   |
      |  |   +--------------------+  |   |
      |  |   | +----+             |  |   |
      |  |   | |+--+|             |  |   |
      |  |   | |^  ||             |  |   |
 int  (  *   ( *foo)( double      )  [3 ];
   |  ^  ^   ^ ^   ||             |  |   |
   |  |  |   | +---+|             |  |   |
   |  |  |   +------+             |  |   |
   |  |  +------------------------+  |   |
   |  +------------------------------+   |
   +-------------------------------------+

Thus, Identifier foo

is a pointer
to function taking double as argument returning
pointer to
array 3
of int

See [here](http://stackoverflow.com/questions/16260417/the-spiral-rule-about-declarations-when-is-it-in-error) for the merits of the spiral rule. — CB Bailey, Jan 01 '14 at 15:21

Get confused with this declaration - int (*(*foo)(double))[3]

2 Answers2

Get confused with this declaration - int ((foo)(double))[3]