What does double* (*p[3]) (void* (*)()); mean?

Question

I am having difficulty trying to understand what the following declaration means. Is this declaration standard?

double* (*p[3]) (void* (*)());

Can anyone help me to understand the meaning of this declaration?

Answer 1

Rule for reading hairy declarations: find the leftmost identifier and work outward, remembering that () and [] bind before *, so T *a[N] is an array of pointers to T, T (*a)[N] is a pointer to an array of T, T *f() is a function returning a pointer to T, and T (*f)() is a pointer to a function returning T. Since a function prototype may omit parameter names, you may see things like T *[N] or T (*)(). The meaning is mostly the same¹, just pretend that there's an identifier of 0 length.

Thus,

          p                      -- p
          p[3]                   -- is a 3-element array
         *p[3]                   -- of pointers
        (*p[3]) (           )    -- to functions
        (*p[3]) (      (*)())    --   taking a pointer to a function
        (*p[3]) (    * (*)())    --   returning a pointer
        (*p[3]) (void* (*)())    --   to void
      * (*p[3]) (void* (*)())    -- returning a pointer
double* (*p[3]) (void* (*)());   -- to double

The important thing to take away here is that you are declaring p as an array of ..., not a function returning ....

What would such a beast look like in practice? Well, first, you need three functions to point to. Each of these functions takes a single parameter, which is a pointer to a function returning a pointer to void:

double *foo(void *(*)());
double *bar(void *(*)());
double *bletch(void *(*)());

double *(*p[3]) (void *(*)()) = {foo, bar, bletch};

Each of foo, bar, and bletch would call the function passed to it and somehow return a pointer to double.

You would also want to define one or more functions that satisfy the parameter type for each of foo, bar, and bletch:

void *blurga() {...}

so if you called foo directly, you'd call it like

double *pv;
...
pv = foo(blurga);

So we could imagine a call like

double *pv = (*p[0])(blurga);

---

^{1 - the difference is that in the context of a function parameter declaration, T a[] and T a[N] are identical to T *a; in all three cases, a is a pointer to T, not an array of T. Note that this is only true in a function parameter declaration. Thus, T *[] will be identical to T **.}