How define an array of function pointers in C

The type of a function pointer is just like the function declaration, but with "(*)" in place of the function name. So a pointer to:

int foo( int )

would be:

int (*)( int )

In order to name an instance of this type, put the name inside (*), after the star, so:

int (*foo_ptr)( int )

declares a variable called foo_ptr that points to a function of this type.

Arrays follow the normal C syntax of putting the brackets near the variable's identifier, so:

int (*foo_ptr_array[2])( int )

declares a variable called foo_ptr_array which is an array of 2 function pointers.

The syntax can get pretty messy, so it's often easier to make a typedef to the function pointer and then declare an array of those instead:

typedef int (*foo_ptr_t)( int );foo_ptr_t foo_ptr_array[2];

In either sample you can do things like:

int f1( int );int f2( int );foo_ptr_array[0] = f1;foo_ptr_array[1] = f2;foo_ptr_array[0]( 1 );

Finally, you can dynamically allocate an array with either of:

int (**a1)( int ) = calloc( 2, sizeof( int (*)( int ) ) );foo_ptr_t * a2 = calloc( 2, sizeof( foo_ptr_t ) );

Notice the extra * in the first line to declare a1 as a pointer to the function pointer.

I put a small example here that may help you

typedef void (*fp)(int); //Declares a type of a void function that accepts an intvoid test(int i){    printf("%d", i);}int _tmain(int argc, _TCHAR* argv[]){    fp function_array[10];  //declares the array    function_array[0] = test;  //assings a function that implements that signature in the first position    function_array[0](10); //call the cuntion passing 10}

You'd declare an array of function pointers as

T (*afp[N])(); 

for some type T. Since you're dynamically allocating the array, you'd do something like

T (**pfp)() = calloc(num_elements, sizeof *pfp);

or

T (**pfp)() = malloc(num_elements * sizeof *pfp);

You'd then call each function as

T x = (*pfp[i])();

or

T x = pfp[i](); // pfp[i] is implicitly dereferenced

If you want to be unorthodox, you can declare a pointer to an array of pointers to functions, and then allocate that as follows:

T (*(*pafp)[N])() = malloc(sizeof *pafp);

although you would have to deference the array pointer when making the call:

x = (*(*pafp)[i])();