Comment définir un tableau de fonctions en C

J'ai une structure qui contient une déclaration comme celle-ci:

void (*functions[256])(void) //Array of 256 functions without arguments and return value

Et dans une autre fonction que j'ai envie de le définir, mais il y a 256 fonctions!
Je pourrais faire quelque chose comme ceci:

struct.functions[0] = function0;
struct.functions[1] = function1;
struct.functions[2] = function2;

Et ainsi de suite, mais c'est trop fatigant, ma question est-il possible de faire quelque chose comme cela?

struct.functions = { function0, function1, function2, function3, ..., };

MODIFIER: erreur de Syntaxe corrigé comme le dit Chris Lutz.

source d'informationauteur 0x77D

arrays c definition function

14

J'ai une structure qui contient une déclaration comme celle-ci:

Non, vous ne le font pas. C'est une erreur de syntaxe. Vous êtes à la recherche pour:
```
void (*functions[256])();
```
Qui est un tableau de pointeurs de fonction. Notez, cependant, que void func() n'est pas une "fonction qui ne prend pas d'argument et ne renvoie rien." C'est une fonction qui prend un quelconque des nombres ou des types d'arguments et ne renvoie rien. Si vous voulez "pas d'arguments" vous avez besoin de ceci:
```
void (*functions[256])(void);
```
En C++, void func() ne signifie "ne prend pas d'arguments", ce qui provoque une certaine confusion (en particulier étant donné que la fonctionnalité C précise pour void func() est d'une valeur douteuse.)

De toute façon, vous devriez typedef votre pointeur de fonction. Il faut rendre le code infiniment plus facile à comprendre, et vous n'aurez qu'une seule chance (à la typedef) pour obtenir la syntaxe de mal:
```
typedef void (*func_type)(void);
//...
func_type functions[256];
```
De toute façon, vous ne pouvez pas attribuer à un tableau, mais vous pouvez initialiser un tableau et de copier les données:
```
static func_type functions[256] = { /* initializer */ };
memcpy(struct.functions, functions, sizeof(functions));
```

Vous pouvez le faire de manière dynamique... Voici un petit exemple d'une fonction dynamique tableau alloué avec malloc...

#include <stdio.h>
#include <stdlib.h>

typedef void (*FOO_FUNC)(int x);

void a(int x)
{
    printf("Function a: %d\n", x);
}

void b(int x)
{
    printf("Function b: %d\n", x);
}

int main(int argc, char **argv)
{
    FOO_FUNC *pFoo = (FOO_FUNC *)malloc(sizeof(FOO_FUNC *) * 2);
    pFoo[0] = (FOO_FUNC)&a;
    pFoo[1] = (FOO_FUNC)&b;

    pFoo[0](10);
    pFoo[1](20);

    return 0;
}

À partir du haut de ma tête et non testé.

//create array of pointers to functions
void (*functions[256])(void) = {&function0, &function1, &function2, ..., };

//copy pointers to struct
int i;
for (i = 0; i < 256; i++) struct.functions[i] = functions[i];

MODIFIER: correction de l'erreur de syntaxe comme le dit Chris Lutz.

J'ai eu le même problème, c'est mon petit programme de test de la solution. Il semble assez simple alors j'ai pensé que je devais le partager pour les futurs visiteurs.

#include <stdio.h>

int add(int a, int b) {
    return a+b;
}

int minus(int a, int b) {
    return a-b;
}

int multiply(int a, int b) {
    return a*b;
}

typedef int (*f)(int, int);                 //declare typdef

f func[3] = {&add, &minus, &multiply};      //make array func of type f,
                                            //the pointer to a function
int main() {
    int i;
    for (i = 0; i < 3; ++i) printf("%d\n", func[i](5, 4));
    return 0;
}

Vous pouvez le faire tout en déclarant votre struct exemple:

function_structur fs = { struct_field1,
                         struct_field2,
                         {function0, function1, ..., function255},
                         struct_field3,
                         ... };

Vous ne pouvez pas utiliser ce raccourci pour initialiser les tableaux après le tableau a été déclaré: si vous avez besoin de le faire, vous aurez à le faire dynamiquement (à l'aide d'une boucle, d'un memcpy ou autre chose).

0

Si vous voulez post-initialiser un tableau en utilisant le formulaire comme {func1, func2, ...}ce qui peut être accompli de la manière suivante (en utilisant GCC):

UPD (grâce à Chris Lutz pour les remarques)

Définir une macro comme ceci:
```
#define FUNCTION_VECTOR_COPY(destVec, sourceVec) memcpy(destVec, sourceVec, sizeof(sourceVec))
```
Et passer de la source de vecteur à l'aide de Composé Littérauxcomme suit:
```
#include <string.h>
...
void (*functions[256])();
...
FUNCTION_VECTOR_COPY (functions, ((void(*[])()) {func1, func2, func3}));
```

Vous devez vous connecter pour publier un commentaire.