How define an array of function pointers in C

I've a little question. I'm trying to define an array of function pointers dynamically with calloc. But I don't know how to write the syntax. Thanks a lot.

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 int

void 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])();

Assuming all your functions are of type void ()(void), something like this

typedef void (*fxptr)(void);
fxptr *ptr; // pointer to function pointer
ptr = malloc(100 * sizeof *ptr);
if (ptr) {
    ptr[0] = fx0;
    ptr[1] = fx1;
    /* ... */
    ptr[99] = fx100;

    /* use "dynamic array" of function pointers */

    free(ptr);
}

typedef R (*fptr)(A1, A2... An);

where R is the return type, A1, A2... An are the argument types.

fptr* arr = calloc(num_of_elements,sizeof(fptr));