Cómo definir una matriz de indicadores de función en C

Tengo una pequeña pregunta. Estoy tratando de definir una matriz de punteros de función de forma dinámica con calloc . Pero no sé cómo escribir la syntax. Muchas gracias.

El tipo de puntero de función es como la statement de la función, pero con “(*)” en lugar del nombre de la función. Entonces un puntero a:

 int foo( int ) 

sería:

 int (*)( int ) 

Para nombrar una instancia de este tipo, coloque el nombre dentro (*), después de la estrella, así:

 int (*foo_ptr)( int ) 

declara una variable llamada foo_ptr que apunta a una función de este tipo.

Las matrices siguen la syntax C normal de poner los corchetes cerca del identificador de la variable, así que:

 int (*foo_ptr_array[2])( int ) 

declara una variable llamada foo_ptr_array que es una matriz de 2 punteros de función.

La syntax puede ser bastante desordenada, por lo que a menudo es más fácil hacer un typedef al puntero a la función y luego declarar una matriz de los mismos:

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

En cualquier muestra puedes hacer cosas como:

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

Finalmente, puede asignar dinámicamente una matriz con cualquiera de:

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

Observe el extra * en la primera línea para declarar a1 como un puntero al puntero a la función.

Pongo un pequeño ejemplo aquí que puede ayudarte

 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 } 

Deberías declarar una matriz de indicadores de función como

 T (*afp[N])(); 

para algunos tipo T Dado que está asignando dinámicamente la matriz, haría algo como

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

o

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

Luego llamarías a cada función como

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

o

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

Si desea ser poco ortodoxo, puede declarar un puntero a una serie de punteros a funciones y luego asignarlo de la siguiente manera:

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

aunque tendrías que respetar el puntero del array al hacer la llamada:

 x = (*(*pafp)[i])(); 
 typedef R (*fptr)(A1, A2... An); 

donde R es el tipo de retorno, A1, A2 … An son los tipos de argumento.

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

Suponiendo que todas sus funciones son de tipo void ()(void) , algo como esto

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