Discussion :

[AuraHxC]

Pour l'instant ça n'a effectivement pas réellement d'intérêt mais comme je l'avais dit précédemment (au tout début), c'est tiré d'un ouvrage "Maîtrise des algorithmes en C" écrit par Kyle Loudon qui utilise dans son ouvrage que des pointeurs de fonction.
Donc comme j'aimerais bien utiliser son code et comprendre les mécanismes, il faut que je comprenne comment tout cela fonctionne.

Ce que j'ai copié/collé c'est exactement ce qu'il y a dans l'ouvrage mais à chaque fois il n'y a pas d'exemple de "main" pour comprendre comment utiliser.

Voilà la motivation de ce post.

[Emmanuel Delahaye]

Ce que j'ai copié/collé c'est exactement ce qu'il y a dans l'ouvrage mais à chaque fois il n'y a pas d'exemple de "main" pour comprendre comment utiliser.

Si c'est vraiment un copié collé, tu peux jeter le livre. Le code est faux. (types incohérents).

[AuraHxC]

ça fait quand même ch***, c'est un bouquin de chez O'reilly je pensais que c'était sérieux...
Je vais regarder le code de nouveau sur le bouquin et je redis si c'est moi qui est fait une bêtise.

[AuraHxC]

Bon comme l'indentation des fichiers que le bouquin propose ne sont pas terrible, je peux te proposer l'adresse où l'on peut télécharger les sources comme ça si ça te dérange pas tu pourrais me donner ton avis.

Pour les listes chaînées simple c'est les fichiers list.h et list.c.

http://www.oreilly.fr/archives/algoc.zip

[AuraHxC]

J'ai vite fait regardé le tuto sur le site developpez.com qui traite des pointeurs et il y a un petit truc sur les pointeurs de fonction.

j'ai fait ce bout de code tout con mais ca permet de comprendre un peu le concept je pense.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
#include <stdio.h>
 
void add(int *a, int *b,int *result) {
    *result = *a+*b;
}
 
int main(void) {
    int a = 5;
    int b = 10;
    int result;
    void(*padd)(int*, int*,int*);
 
    padd = add;
    padd(&a,&b,&result);
 
    printf("resultat : %d\n",result);
 
    return 0;
}

[AuraHxC]

Sinon Emmanuel, je viens de voir la critique sur developpez.com de mon ouvrage et il est plutôt bien noté donc c'est qu'il ne doit pas être aussi nul que ça, non ?

J'attend de voir tes réactions sur le code que je t'ai donné en lien
Enfin si ça te dérange pas bien entendu...

[souviron34]

mmm moi j'aurais plutôt présenté comme ceci ton exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
33
34
35
36
 
#include <stdio.h>
 
typedef struct {
   int a ;
   int b ;
   int result ;
} MonData ;
 
 
void add (void *Data) 
{
   MonData *mdata = (MonData *)Data ;
 
    mdata->result = mdata->a + mdata->b;
}
 
 
void Fonction ( void MaFonction, void *Data )
{
      MaFonction ( Data );
}
 
int main(void) {
    MonData Data ;
 
    Data.a = 5;
    Data.b = 10;
    Data.result = 0;
 
    Fonction ( add, (void *)&Data );
 
    printf("resultat : %d\n",Data.result);
 
    return 0;
}

Mais pour faire un code "éducatif", j'aurais fait la chose suivante :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
 
#include <stdio.h>
 
typedef struct {
   int a ;
   int b ;
   int result ;
} MonData ;
 
 
typedef struct {
     int     Type ;
     void *AdrFct ;
     void *Data ;
} Fct ;
 
#define ADD  1
 
#ifndef SUCCESS
#define SUCCESS 0
#define ERROR 1
#endif
 
 
static Fct *Fcts=NULL ;
static int    NFcts=0 ;
 
void add (void *Data) 
{
   MonData *mdata = (MonData *)Data ;
 
    mdata->result = mdata->a + mdata->b;
}
 
 
int StockeFonction ( int Type, void *MaFct, void *Data )
{
   Fct tmp =NULL ;
 
    if ( NFcts == 0 )
      {
          Fcts = calloc ( 1, sizeof(Fct) );
          if ( Fcts == NULL )
             return ERROR ;
      }
    else
      {
         tmp = realloc ( Fcts, ((NFcts+1)*sizeof(Fct)) );
         if ( tmp == NULL )
           return ERROR ;
         Fcts = tmp ;
      }
 
    Fcts[NFcts].Adr = MaFct ;
    Fcts[NFcts].Type = Type ;
    Fcts[NFcts].Data = Data ;
    NFcts = NFcts + 1 ;
 
    return SUCCESS ;
}
 
 
void AppelleFonction ( int Type )
{
   int i ;
 
   for ( i = 0 ; i < NFcts ; i++ )
      if ( Fcts[i].Type == Type )
         {
            Fcts[i].Adr ( Fct[i].Data );
            return ;
          }
}
 
int main(void) {
    MonData Data ;
 
    Data.a = 5;
    Data.b = 10;
    Data.result = 0;
 
    if ( StockeFonction ( ADD, (void *)&add, (void *)&Data ) )
      {
         fprintf ( stderr, "\nUne erreur s'est produite...\n");
         return EXIT_FAILURE ;
      }
 
    AppelleFonction ( ADD );
 
    printf("resultat : %d\n",Data.result);
 
    return EXIT_SUCCESS ;
}

ps : je n'ai pas essayé de faire marcher avec des fonctions void, mais c'est le principe. Je fais beaucoup ça, mais avec des fonctions qui retournent un entier...

Dans ce cas je met une définition de fonction comme ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
typedef int MAPROC (void *data);
 
typedef struct {
    int     Type ;
    MAPROC *Adr ;
    void   *Data ;
} Fct ;

et c'est appelé comme :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 int statut ;
 
   statut = Fcts[i].Adr(Fcts[i].Data);

[acx01b]

salut


void Fonction ( void MaFonction, void *Data )
{
MaFonction ( Data );
}

?????????
c'est pas vraiment du C !

[AuraHxC]

C'est bon je capte plutot bien ton code.

Sinon si c'est du C --> Il utilise des pointeurs de fonction c'est assez compréhensible comme il le propose

[souviron34]

comme je disais j'ai pas testé avec des fonctions void, mais c'est le principe, et ça correspond exactement à ce qu'Emmanuel présentait et à ton titre.

En fait, ce genre de chose sert comme le disait Emmanuel à faire par exemple les gestionnaires d'événements dans les bibliothèques de GUI comme X, GTK, etc..

tu as un widget (un bouton par exemple). Sur cet objet, plusieurs actions sont possibles (armer, clicker, etc..).

Le gestionnaire implémente donc un mécasnisme comme décrit ci-dessus disant :

Si l'utilisateur veut mettre une action sur le fait de cliquer, enregistres la fonction qu'il donne (celle qui est écrite dans le RAD : boutonmachintruc.clicker). Elle a des paramètres internes (que je n'ai pas mis ici) plus un paramètre sur les données utilisateurs (le data).

Dans le gestionnaire, il y a une boucle qui dit :

• Si c'est un click
  
• Si c'est sur un bouton
  
• On appelle la fonction interne (par exemple changer l'ombrage pour indiquer que c'est enfoncé)
• Est-ce que ce bouton a une fonction enregistrée par l'utilisateur ?
  
• Oui, alors on l'appelle

[souviron34]

salut


void Fonction ( void MaFonction, void *Data )
{
MaFonction ( Data );
}

?????????
c'est pas vraiment du C !

Ah oui ? et pourquoi pas ?

[souviron34]

Bon je vais mettre un code propre (avec les void je suis pas certain que les adresses et les stockages marchent totalement) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
 
 
#include <stdio.h>
 
typedef struct {
   int a ;
   int b ;
   int result ;
} MonData ;
 
typedef int MAPROC (void *data);
 
typedef struct {
    int     Type ;
    MAPROC *Adr ;
    void   *Data ;
} Fct ;
 
 
#define ADD  1
 
#ifndef SUCCESS
#define SUCCESS 0
#define ERROR 1
#endif
 
 
static Fct *Fcts=NULL ;
static int    NFcts=0 ;
 
MAPROC add (void *Data) 
{
   MonData *mdata = (MonData *)Data ;
 
    mdata->result = mdata->a + mdata->b;
 
   return SUCCESS ;
}
 
 
int StockeFonction ( int Type, MAPROC *MaFct, void *Data )
{
   Fct tmp =NULL ;
 
    if ( NFcts == 0 )
      {
          Fcts = calloc ( 1, sizeof(Fct) );
          if ( Fcts == NULL )
             return ERROR ;
      }
    else
      {
         tmp = realloc ( Fcts, ((NFcts+1)*sizeof(Fct)) );
         if ( tmp == NULL )
           return ERROR ;
         Fcts = tmp ;
      }
 
    Fcts[NFcts].Adr = MaFct ;
    Fcts[NFcts].Type = Type ;
    Fcts[NFcts].Data = Data ;
    NFcts = NFcts + 1 ;
 
    return SUCCESS ;
}
 
 
int AppelleFonction ( int Type )
{
   int i, j ;
 
   for ( i = 0 ; i < NFcts ; i++ )
      if ( Fcts[i].Type == Type )
         {
            j = Fcts[i].Adr ( Fct[i].Data );
            return j ;
          }
}
 
int main(void) {
    MonData Data ;
 
    Data.a = 5;
    Data.b = 10;
    Data.result = 0;
 
    if ( StockeFonction ( ADD, (MAPROC *)&add, (void *)&Data ) )
      {
         fprintf ( stderr, "\nUne erreur s'est produite...\n");
         return EXIT_FAILURE ;
      }
 
    AppelleFonction ( ADD );
 
    printf("resultat : %d\n",Data.result);
 
    return EXIT_SUCCESS ;
}

[AuraHxC]

Merci pour toutes ces précisions
Et je ne doutais pas du tout que c'était du C ce que tu avais mis
J'ai même capté à la première lecture ce que tu faisais

[Emmanuel Delahaye]

Bon je vais mettre un code propre (avec les void je suis pas certain que les adresses et les stockages marchent totalement) :
<...>

Ahem... Tu n'as pas compilé le code posté, çaÿ mal.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
Compilateur: Default compiler
Building Makefile: "C:\dev\forums\Makefile.win"
Exécution de  make...
make.exe -f "C:\dev\forums\Makefile.win" all
gcc.exe -c main.c -o main.o -I"C:/Dev-Cpp/include"  -I"/clib"    -Wextra -Wall -O2
 
main.c:30: error: `add' declared as function returning a function
main.c: In function `StockeFonction':
main.c:41: error: invalid initializer
main.c:45: warning: implicit declaration of function `calloc'
 
main.c:51: warning: implicit declaration of function `realloc'
 
main.c:51: error: incompatible types in assignment
main.c:52: error: invalid operands to binary ==
main.c:54: error: incompatible types in assignment
main.c: In function `AppelleFonction':
main.c:73: error: syntax error before "Fct"
main.c: In function `main':
main.c:88: error: `EXIT_FAILURE' undeclared (first use in this function)
main.c:88: error: (Each undeclared identifier is reported only once
main.c:88: error: for each function it appears in.)
main.c:95: error: `EXIT_SUCCESS' undeclared (first use in this function)
 
make.exe: *** [main.o] Error 1
 
Exécution terminée

En dehors des erreurs signalées, il y des casts et des & inutiles. Ceci compile :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
 
#include <stdio.h>
#include <stdlib.h>
 
typedef struct {
   int a ;
   int b ;
   int result ;
} MonData ;
 
typedef int MAPROC (void *data);
 
typedef struct {
    int     Type ;
    MAPROC *Adr ;
    void   *Data ;
} Fct ;
 
 
#define ADD  1
 
#ifndef SUCCESS
#define SUCCESS 0
#define ERROR 1
#endif
 
static Fct *Fcts=NULL ;
static int    NFcts=0 ;
 
int add (void *Data)
{
   MonData *mdata = Data ;
 
    mdata->result = mdata->a + mdata->b;
 
   return SUCCESS ;
}
 
 
int StockeFonction ( int Type, MAPROC *MaFct, void *Data )
{
   Fct *tmp =NULL ;
 
    if ( NFcts == 0 )
      {
          Fcts = calloc ( 1, sizeof(Fct) );
          if ( Fcts == NULL )
             return ERROR ;
      }
    else
      {
         tmp = realloc ( Fcts, ((NFcts+1)*sizeof(Fct)) );
         if ( tmp == NULL )
           return ERROR ;
         Fcts = tmp ;
      }
 
    Fcts[NFcts].Adr = MaFct ;
    Fcts[NFcts].Type = Type ;
    Fcts[NFcts].Data = Data ;
    NFcts = NFcts + 1 ;
 
    return SUCCESS ;
}
 
int AppelleFonction ( int Type )
{
   int i, j=-1 ;
 
   for ( i = 0 ; i < NFcts ; i++ )
      if ( Fcts[i].Type == Type )
         {
            j = Fcts[i].Adr ( Fcts[i].Data );
         }
   return j ;
}
 
int main(void) {
    MonData Data ;
 
    Data.a = 5;
    Data.b = 10;
    Data.result = 0;
 
    if ( StockeFonction ( ADD, add, &Data ) )
      {
         fprintf ( stderr, "\nUne erreur s'est produite...\n");
         return EXIT_FAILURE ;
      }
 
    AppelleFonction ( ADD );
 
    printf("resultat : %d\n",Data.result);
 
    return EXIT_SUCCESS ;
}

Attention, à vue de nez, ce qui a été alloué n'a pas été libéré...

[souviron34]

Ahem... Tu n'as pas compilé le code posté, çaÿ mal.

OUI c'est vrai....



J'ai juste voulu donner un exemple en copiant des morceaux de code que j'avais, pas faire un truc compilable... Désolé..

Attention, à vue de nez, ce qui a été alloué n'a pas été libéré...

Même réponse .. Même faute.. Encore une fois désolé ..

[AuraHxC]

Tiens j'ai remarqué qu'il y avait un commentaire dans la fonction list_destroy qui utilise un pointeur de fonction :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
/*appel d'une fonction utilisateur pour libérer */
/*les données allouées dynamiquement         */

Comme on a parlé dans ce thread de fonction utilisateur, ben je viens de tilter sur le fait que je vois pas exactement ce que c'est... Quand il met ça en commentaire, est ce que ca veut dire qu'il faut que je fasse une fonction pour supprimer ma liste ?

Je remets du code pour une meilleur compréhension :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
typedef struct ListElmt_ {
    void *donnee;
    struct ListElmt_ *suivant;
} ListElmt;
 
typedef struct List_ {
    int taille;
    int (*corresp)(const void *val1,const void *val2);
    void (*detruire)(void *donnee);
    ListElmt *tete;
    ListElmt *queue;
} List;

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
void list_init(List *liste, void (*detruire)(void *donnee)) {
    liste->taille   = 0;
    liste->detruire = detruire;
    liste->tete     = NULL;
    liste->queue    = NULL;
 
    return;
}
 
void list_destroy(List *liste) {
    void *donnee;
 
    while (list_size(liste) > 0) {
 
         if (list_rem_next(liste, NULL, (void **)&donnee) == 0 && liste->detruire !=  NULL) {
 
      /*****************************************************
      *                                                    *
      *  Appel d'une fonction utilisateur pour libérer     *
      *  les données allouées dynamiquement.               *
      *                                                    *
      *****************************************************/
 
                liste->detruire(donnee);
   }
}
 
    memset(liste, 0, sizeof(List));
 
    return;
}

J'ai essayé de faire de mon mieux pour réindenter le code, j'espère que ça donne pas trop mal.

Merci d'avance pour vos réponse, ça va sûrement bien m'aider.

[souviron34]

ben oui...

sa structure est générique. Il gère une liste quelconque...

Dans cette liste, on a des TAD (ou des objets opaques si tu préfères).

Donc dans ces objets tu peux avoir des choses allouées.

Donc avant de détruire l'objet, il faut éventuellement détruire ce qui a été alloué.

Comme la structure est générique, elle n'a aucun moyen de savoir si des choses ont été allouées ou non. En conséquence c'est au programme appellant de définir la(les) routine(s) de destruction interne.

[AuraHxC]

Donc il faut que je définisse une fonction qui permette de détruire les données de ma liste... Je vais y aller par étape parce que ce genre d'implémentation j'en ai jamais vu donc j'ai un peu de mal à capter correctement.