web-dev-qa-db-fra.com

Comment définir un tableau de pointeurs de fonction en C

J'ai une petite question. J'essaie de définir un tableau de pointeurs de fonction dynamiquement avec calloc. Mais je ne sais pas comment écrire la syntaxe. Merci beaucoup.

c++carraysfunction-pointers
45
strstr

Le type d'un pointeur de fonction est identique à la déclaration de fonction, mais avec "(*)" à la place du nom de la fonction. Donc, un pointeur vers:

int foo( int )

serait:

int (*)( int )

Afin de nommer une instance de ce type, mettez le nom entre (*), après l'étoile, donc:

int (*foo_ptr)( int )

déclare une variable appelée foo_ptr qui pointe vers une fonction de ce type.

Les tableaux suivent la syntaxe C normale de placer les crochets près de l'identifiant de la variable, donc:

int (*foo_ptr_array[2])( int )

déclare une variable appelée foo_ptr_array qui est un tableau de 2 pointeurs de fonction.

La syntaxe peut devenir assez compliquée, il est donc souvent plus facile de créer un typedef vers le pointeur de fonction, puis de déclarer un tableau de ceux-ci à la place:

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

Dans les deux exemples, vous pouvez faire des choses comme:

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

Enfin, vous pouvez allouer dynamiquement un tableau avec l'un des éléments suivants:

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

Notez le supplément * dans la première ligne pour déclarer a1 comme pointeur vers le pointeur de fonction.

110
Andrew Eidsness

Je mets ici un petit exemple qui peut vous aider

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

}
5
Andres

Vous déclareriez un tableau de pointeurs de fonction comme

T (*afp[N])();

pour certains types T. Puisque vous allouez dynamiquement le tableau, vous feriez quelque chose comme

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

ou

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

Vous appelez ensuite chaque fonction comme

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

ou

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

Si vous voulez ne pas être orthodoxe, vous pouvez déclarer un pointeur vers un tableau de pointeurs vers des fonctions, puis l'allouer comme suit:

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

bien que vous deviez déférer le pointeur du tableau lors de l'appel:

x = (*(*pafp)[i])();
4
John Bode

En supposant que toutes vos fonctions sont de type void ()(void), quelque chose comme ça

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);
}
1
pmg
typedef R (*fptr)(A1, A2... An);

où R est le type de retour, A1, A2 ... An sont les types d'argument.

fptr* arr = calloc(num_of_elements,sizeof(fptr));
1
Armen Tsirunyan