array of N pointers to functions returning pointers to functions

Question

This was asked to me in an interview! i really got confused

• How do I declare an array of N pointers to functions returning pointers to functions returning pointers

Answer 1

Divide big problem into smaller parts:

/* char_func_ptr is pointer to function returning pointer to char */
typedef char* (*char_func_ptr)();

/* func_func_ptr is a pointer to function returning above type */
typedef char_func_ptr (*func_func_ptr)();

/* the_array is array of desired function pointers */
func_func_ptr the_array[42];

Answer 2

Using typedefs as Christopher tells you is really th only humane way of declaring such a thing. Without tyedefs , it'll become:

char *(*(*arr[10])(void ))(void );

(yes I had to cheat and ran cdecl> declare arr as array 10 of pointer to function(void) returning pointer to function(void) returning pointer to char )

Answer 3

Typedefs are for wusses. Here's a straightforward, mechanical method for figuring out hairy declarations:

          a                 -- a
          a[N]              -- is an N-element array
         *a[N]              -- of pointers
        (*a[N])()           -- to functions
       *(*a[N])()           -- returning pointers
      (*(*a[N])())()        -- to functions
     *(*(*a[N])())()        -- returning pointers
char *(*(*a[N])())()        -- to char.  

So, the answer is in the neighborhood of char *(*(*a[N])())();. I say "in the neighborhood" since it's never specified what arguments the functions take.

It's an obnoxious interview question (types this ugly are truly rare IME), but it does give the interviewer an idea of how well you understand declarators. Either that or they were bored and just wanted to see if they could make your brain sieze.

EDIT

Most everyone else recommends using typedefs. The only time I recommend using a typedef is if the type is intended to be truly opaque (i.e., not manipulated directly by the programmer, but passed to an API, sort of like the FILE type). Otherwise, if the programmer is meant to manipulate objects of that type directly, then IME it's better to have all that information available in the declaration, ugly as it may be. For example, something like

 NameFuncPickerPointer a[N];

gives me no information on how to actually use a[i]. I don't know that a[i] is callable, or what it returns, or what arguments it should take (if any), or much of anything else. I have to go looking for the typedef

typedef char *NameFunc();
typedef NameFunc *NameFuncPicker();
typedef NameFuncPicker *NameFuncPickerPointer;

and from that puzzle out how to write the expression that actually calls one of the functions. Whereas using the "naked", non-typedef'd declaration, I know immediately that the structure of the call is

char *theName = (*(*a[i])())();

Answer 4

typedef char* (* tCharRetFunc)();
typedef tCharRetFunc (* tFuncRetCharFunc)();

tFuncRetCharFunc arr[N];

Answer 5

array of N pointers to functions returning pointers to functions returns a char:

int (*(*arr_fp[n])(void))(void)

Answer 6

Is this what you are looking for:

typedef char* charptr;
typedef charptr (*innerfun)();
typedef innerfun (*outerfun)();

const size_t N = 10;
outerfun my_outerfun_array[N];

I hope I got it correct, it seems a strange question to me especially in an interview :(