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.

Answers


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

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));

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);
}

Need Your Help

Profiling PHP code

php performance profiling

I'd like to find a way to determine how long each function in PHP, and each file in PHP is taking to run. I've got an old legacy PHP application that I'm trying to find the "rough spots" in and so...

POST data to a URL in PHP

php post

How can I send POST data to a URL in PHP (without a form)?