adresse d'une fonction dans une structure

Version imprimable

Bonjour,

Je souhaite mettre une adresse de fonction dans une structure et la lancer ensuite.

Je m'explique

Soit le code suivante
Code:

1 2 3 4 5 6 7 8 9 10 struct stra { // Liste des variables ... void *fonction // Ici mon adresse de fonction ou quelque chose comme ça } struct stra util; // Instructions diverses util->fonction // Ici l'utilisation de ma fonction ou quelque chose comme ça
Je ne suis pas sur qu'écrit comme c'est écrit mon code fonctionne.
Je voudrais savoir comment l'écrire avec la bonne syntaxe

Je voudrais savoir aussi comment on écrit la définition de la fonction (son entête et ses paramètres muets)

Merci d'avance

Bonjour,

Les pointeurs de fonction sont presque des variables comme les autres.

Voici un exemple sans structure encore :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
void fun(void)
{
    printf("hello from fun\n");
}
 
int main()
{
    /* déclaration de la variable f qui est
     un pointeur sur une fonction void(void)*/
    void (*f)(void);
 
    /* définition de f*/
    f = fun;
 
    /* appel de f*/
    f();
 
    return 0;
}

Avec structure :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
void fun(void)
{
    printf("hello from fun\n");
}
 
struct toto {
    void (*f)(void);
    int autre;
};
 
int main()
{
    struct toto mon_toto;
 
    mon_toto.f = fun;
 
    mon_toto.f();
 
    return 0;
}

21/08/2008, 16h08
Melem

Citation:

Envoyé par mabu

Les pointeurs de fonction sont presque des variables comme les autres.

Pourquoi presque ? Un pointeur de fonction et une variable qui contient l'adresse d'une fonction c'est tout. C'est les fonctions elle-mêmes qui sont un peu particuliers car f est toujours convertit par le compilateur en &f sauf quand elle est utilisée avec sizeof (sizeof(f), qui n'est pas une expression valide car on ne peut pas connaître la taille d'une fonction sachant seulement son type) ou avec l'opérateur * (*f, qui est égal à *(&f) soit f soit ... &f !).

FAQ : Comment déclarer un pointeur sur une fonction ?

Je suis un peu embêter car je crois que je me suis un peu emmêlé les pinceaux avec mes pointeurs. :?
En fait ce n'est pas l'adresse d'une fonction que je déclare dans une structure mais l'adresse d'une fonction déclarée dans une structure pointée de structure.

Ca donne ça
Un fichier include dec_struct.h
Code:

1 2 3 4 5 6 7 8 9 10 struct tata_s { int (*fct)(void) } #define maTata struc tata_s struct toto_s { maTata *ma_tata } #define monToto struct toto_s
Et pour le programme
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 #include "dec_struct.h" int main { monToto toto={{util}} util_struct(&toto) } void util_struct(*p) { p->ma_tata.fct() } int util(void) { printf("hello from function in structure\n"); }
Je sais ça semble un peu tordu mais si vous voyez mon programme et son utilisation vous comprendriez mais j'ai probablement mal déclaré qqch parce que ça ne marche pas

Pourrais-tu au moins donner du code avec un minimum d'erreur ?

Code:

1
2
3
4
5
6
7
8
9
10
11
struct tata_s {
    int (*fct)(void); /* Point-virgule */
}; /* Point-virgule */
 
#define maTata struct tata_s /* struct tata_s */
 
struct toto_s {
    maTata * ma_tata; /* Point-virgule */
}; /* Point-virgule */
 
#define monToto struct toto_s

Si tu ne sais pas quand il faut mettre un point-virgule et quand est-ce qu'il ne faut pas, relis les bases du C au lieu de jouer avec des pointeurs et des structures. Ca ne t'aidera pas.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#include "dec_struct.h"
#include <stdio.h> /* Car nous utilisons printf */
 
int util(void); /* Il faut declarer util avant de l'utiliser */
void util_struct(monToto * p); /* Il faut declarer util_struct avant de l'utiliser */
 
int main(void) /* (void) */
{
    monToto toto; /* Ne complique pas les choses si tu ne les maitrise pas encore */
    maTata tata; /* toto.ma_tata doit pointer sur une structure maTata, nous utiliserons tata */
 
    toto.ma_tata = &tata;
    /* tata.fct doit pointer sur une fonction qui retourne un int et qui ne prend aucun argument, prenons util */
    tata.fct = &util; /* ou simplement tata.fct = util (deja explique pourquoi, relis les posts precedents) */
    /* On aurait pu egalement faire tata.fct = util avant toto.ma_tata = &tata, cela ne change rien */
 
    util_struct(&toto);
 
    return 0; /* main doit retourner un int. Les programmeurs retournent generalement 0 pour indiquer un succes */
}
 
void util_struct(monToto * p) /* monToto * (pointeur vers une structure monToto) */
{
    p->ma_tata->fct(); /* ma_tata est un maTata * donc -> au lieu de . */
}
 
int util(void)
{
    printf("hello from function in structure\n");
 
    return 0; /* util doit retourner un int ... */
}

Pour les types, utiliser typedef est mieux qu'un define, voir dans un tutoriel pourquoi.

Code:

1
2
typedef struct tata_s maTata;
typedef struct toto_s monToto;

22/08/2008, 11h02
VITALTH

Bonjour,
Désolé pour les fautes, je n'ai pas véritablement été rigoureux sur ce coup là : j'ai été trop omnubilé sur mon code et sur ce qui me dérangeait sur ma fonction dans mes structures.

C'est gentil d'avoir essayé de m'aider mais j'ai trouvé mon erreur tout seul (le programme que j'ai donné n'est qu'une représentation simplifiée du code que je souhaite faire évoluer.

Il s'agit d'un code que je n'ai pas écrit moi-même mais que j'essais d'adapter à l'usage.

Ce que vous m'avez donné sur les fonctions dans les structures me suffit en fait pour me débrouiller tout seul en réflechissant un peu.