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

Solución:

El tipo de puntero de función es como la declaración de función, pero con “

int foo( int )

“en lugar del nombre de la función. Por lo tanto, un puntero a:

int (*)( int )

sería:

int (*foo_ptr)( int )

Para nombrar una instancia de este tipo, ponga el nombre dentro

después de la estrella, entonces:

int (*foo_ptr_array[2])( int )

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

Las matrices siguen la sintaxis normal de C de poner los corchetes cerca del identificador de la variable, entonces:

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

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

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

La sintaxis puede volverse bastante complicada, por lo que a menudo es más fácil hacer un typedef para el puntero de la función y luego declarar una matriz de esos en su lugar:

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

En cualquiera de las muestras, puede hacer cosas como:

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

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

}

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

T (*afp[N])(); 

Aquí pongo un pequeño ejemplo que puede ayudarte TDeclararía una matriz de punteros de función como

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

para algún tipo

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

. Dado que está asignando dinámicamente la matriz, haría algo como

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

o

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

Luego llamarías a cada función como

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

o

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

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

aunque tendría que respetar el puntero de la matriz al realizar la llamada:

---

---

Utiliza Nuestro Buscador