Pointeur de fonction

**AuraHxC** · 07/12/2006, 18h39

Je m'attaque à la compréhension d'un concept très peu utilisé en langage C mais j'aimerais comprendre quand meme donc si il y a des gens qui capte ce concept

Je vous lache un bout de code comme 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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
/**************************************************************
*                                                                                                                        *
*  ------------------------- list.h ------------------------  *
*                                                                                                                        *
**************************************************************/
 
#ifndef LIST_H
#define LIST_H
 
#include <stdlib.h>
 
/***************************************************************
*                                                                                                                         *
*  Définition de la structure pour les éléments de la liste  *
*                                                                                                                         *
***************************************************************/
 
typedef struct ListElmt_ {
 
void			   *donnee;
struct ListElmt_   *suivant;
 
} ListElmt;
 
/****************************************************************
*                                                                                                                          *
*  Définition d'une structure pour les listes chaînées                 *
*                                                                                                                          *
****************************************************************/
 
typedef struct List_ {
 
int				taille;
 
int				(*corresp)(const void *val1, 
							  const void *val2);
void			   (*detruire)(void *donnee);
 
ListElmt		   *tete;
ListElmt		   *queue;
 
} List;
 
/***************************************************************
*                                                                                                                         *
*  ----------------- Interface publique ---------------------  *
*                                                                                                                         *
***************************************************************/
 
void list_init(List *liste, void (*detruire)(void *donnee));
 
void list_destroy(List *liste);

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
 
/************************************************************
*                                                                                                                  *
*  ------------------------ list.c -----------------------  *
*                                                                                                                  *
************************************************************/
 
#include <stdlib.h>
#include <string.h>
 
#include "list.h"
 
/***********************************************************
*                                                                                                                 *
*  ---------------------- list_init ---------------------  *
*                                                                                                                 *
***********************************************************/
 
void list_init(List *liste, 
			   void (*detruire)(void *donnee)) {
 
/************************************************************
*                                                                                                                  *
*  Initialisation de la liste.                                                    *
*                                                                                                                  *
************************************************************/
 
liste->taille   = 0;
liste->detruire = detruire;
liste->tete	 = NULL;
liste->queue	= NULL;
 
return;
 
}
 
/*************************************************************
*                                                                                                                       *
*  ---------------------- list_destroy --------------------  *
*                                                                                                                       *
*************************************************************/
 
void list_destroy(List *liste) {
 
void			   *donnee;
 
/*************************************************************
*                                                                                                                       *
*  Suppression de chaque élément.                                                     *
*                                                                                                                       *
*************************************************************/
 
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);
 
   }
 
}
 
/************************************************************
*                                                                                                                  *
*  Aucune opération n'est encore permise, mais on nettoie   *
*  la structure par précaution.                                                         *
*                                                                                                                  *
************************************************************/
 
memset(liste, 0, sizeof(List));
 
return;
 
}

Alors mon truc c'est que je sais pas du tout comment dans mon main je vais pouvoir utiliser les structures et les fonctions que j'ai mise (init et destroy) à cause de ces pointeurs de fonction.

Donc si quelqu'un y arrive ca m'interesse

Merci d'avance.

**Emmanuel Delahaye** · 07/12/2006, 18h56

Envoyé par AuraHxC

Je m'attaque à la compréhension d'un concept très peu utilisé en langage C

Tu parles de pointeurs de fonctions ? C'est une plaisanterie ? Les interpréteurs de commandes, les automates (FSM) et toute la programmation par évènement (GUI, par exemple) est basée sur l'utilisation des pointeurs de fonctions. C'est aussi le seul moyen de réaliser des composants logiciels indépendant des sorties.

http://emmanuel-delahaye.developpez.com/complog.htm

C'est certes un concept 'avancé' du langage (encore qu'il n'est pas propre à celui-ci), mais peu connu, non (à part des débutants, bien sûr).

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 List_ {
 
int				taille;
 
int				(*corresp)(const void *val1, 
							  const void *val2);
void			   (*detruire)(void *donnee);
 
ListElmt		   *tete;
ListElmt		   *queue;
 
} List;

Purée, c'est quoi cette présentation à la gomme ? 'indenter', ça te dit quelque chose ?

Alors mon truc c'est que je sais pas du tout comment dans mon main je vais pouvoir utiliser les structures et les fonctions que j'ai mise (init et destroy) à cause de ces pointeurs de fonction.

Donc si quelqu'un y arrive ca m'interesse

Ca c'est pas dur,

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
 
#include "list.h"
 
void cb_detruire (void *donnee)
{
}
 
int main (void)
{
   List x;
 
   list_init (&x, cb_detruire);
   list_destroy (&x);
 
   return 0;
}

mais déjà, il faudrait que ton code compile...

Dans list.h, il manque un #endif.
Dans list.c,
Appel de la fonction inconnue list_size
Appel de la fonction inconnue list_rem_next

**AuraHxC** · 07/12/2006, 19h01

En fait ce code est tiré du bouquin "Maitrise des Algorithme en C" de Kyle Loudon chez O'reilly. Donc je pense que ca doit etre pas mal quand meme non ?
J'ai acheté ce bouquin pour juste avoir sous la main les Algos de base au cas ou mais tous est fait de cette manière donc j'ai un peu de mal à le suivre dans son raisonnement.

Edit : L'indentation je connais bien

j'ai juste fait un copier/coller des sources fournit avec le bouquin. Je code pas comme ca hein lol (enfin niveau de la présentation de mon code).

**Emmanuel Delahaye** · 07/12/2006, 19h12

Envoyé par AuraHxC

En fait ce code est tiré du bouquin "Maitrise des Algorithme en C" de Kyle Loudon chez O'reilly. Donc je pense que ca doit etre pas mal quand meme non ?

Oui, j'ai retiré ma diatribe. On est d'accord, c'est correct. Je pensais aux fonctions 'internes'. Désolé.

Edit : L'indentation je connais bien

j'ai juste fait un copier/coller des sources fournit avec le bouquin. Je code pas comme ca hein lol (enfin niveau de la présentation de mon code).

Ben alors il va falloir apprendre à utiliser un indenteur.

http://emmanuel-delahaye.developpez....tm#indentation

**AuraHxC** · 07/12/2006, 19h16

Pour l'indentation, je suis d'accord c'est juste que j'ai fait un pur copier/coller du fichier ouvert avec DevC++. La prochaine fois je le referais correctement avant de le poster

**Gruik** · 07/12/2006, 20h24

Oué, ça fait peur au debut, mais en fait c'est simple et on peut faire des choses tres puissantes avec.
D'apres moi c'est un peu l'ancentre de l'heritage

**AuraHxC** · 07/12/2006, 19h09

Envoyé par Emmanuel Delahaye

Dans list.h, il manque un #endif.
Dans list.c,
Appel de la fonction inconnue list_size
Appel de la fonction inconnue list_rem_next
analyse en cours ...

Sinon Pour tes erreurs c'est normal j'ai mis des extraits du code. Je pensais pas que le code entier était interessant pour ma question.

Pointeur de fonction

C

Vue hybride

Discussions similaires

Partager

Partager