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

J'ai une petite question.
Je suis en train de créer un tableau de pointeurs de fonction dynamiquement avec calloc.
Mais je ne sais pas comment écrire la syntaxe.
Merci beaucoup.

Pouvez-vous nous montrer ce que vous avez écrit jusqu'à maintenant?

InformationsquelleAutor strstr | 2011-03-30

arrays c c++function-pointers

109

Le type d'un pointeur de fonction est tout comme la déclaration de la fonction, mais avec "(*)" à la place du nom de la fonction. Donc un pointeur vers:
```
int foo( int )
```
serait:
```
int (*)( int )
```
Dans le but de désigner une instance de ce type, de mettre le nom à l'intérieur (*), 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.

Tableaux de suivre la normale de la syntaxe du C de mettre les parenthèses près de la variable identifiant, 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 obtenir assez salissante, de sorte qu'il est souvent plus facile de faire un typedef pour le pointeur de fonction et ensuite déclarer un tableau de la place:
```
typedef int (*foo_ptr_t)( int );
foo_ptr_t foo_ptr_array[2];
```
Dans l'exemple, 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:
```
int (**a1)( int ) = calloc( 2, sizeof( int (*)( int ) ) );
foo_ptr_t * a2 = calloc( 2, sizeof( foo_ptr_t ) );
```
Avis supplémentaires * dans la première ligne de déclarer a1 comme un pointeur vers le pointeur de fonction.
- J'ai essayé votre dernier exemple, et cela fonctionne, mais, qu'en est coulée calloc résultat? n'est-il pas nécessaire? par exemple: int (**a1)( int ) = (some_casting) calloc( 2, sizeof( int (*)( int ) ) );
- Le casting n'est pas nécessaire en C. Le void * type de convertir implicitement à tout autre pointeur vers un objet de type.
- typedef int (*foo_ptr_t)( int ); ne doit pas être présente comme suit: typedef int (*foo_ptr_t)( int ) foo_ptr_t; s'il vous Plaît corrigez-moi si je me trompe
- vous avez tort
InformationsquelleAutor Andrew Eidsness

J'ai mis un petit exemple ici qui peuvent 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

}

InformationsquelleAutor Andres

4

Vous vous souhaitez déclarer un tableau de pointeurs de fonction en tant que
```
T (*afp[N])(); 
```
pour certains type de T. Puisque vous êtes alloue dynamiquement le tableau, vous feriez quelque chose comme
```
T (**pfp)() = calloc(num_elements, sizeof *pfp);
```
ou
```
T (**pfp)() = malloc(num_elements * sizeof *pfp);
```
Vous devez ensuite appeler la fonction comme
```
T x = (*pfp[i])();
```
ou
```
T x = pfp[i](); //pfp[i] is implicitly dereferenced
```
Si vous voulez être peu orthodoxe, vous pouvez déclarer un pointeur vers un tableau de pointeurs de fonctions, et ensuite d'allouer que, comme suit:
```
T (*(*pafp)[N])() = malloc(sizeof *pafp);
```
bien que vous avez la déférence le pointeur sur le tableau lors de la prise de l'appel:
```
x = (*(*pafp)[i])();
```
InformationsquelleAutor John Bode
1
```
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));
```
InformationsquelleAutor Armen Tsirunyan

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

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

InformationsquelleAutor pmg

Vous devez vous connecter pour publier un commentaire.