Du code réutilisable ?

Version imprimable

21/07/2006, 11h33
tintin72

Du code réutilisable ?
Bonjour,

J'essaie de coder une liste chainée de façon à ce qu'elle soit le plus réutilisable possible.
Dans mon code je définit le type de données à manipuler dans le header:
Code:

1 2 typedef int TYPE; //ici par exemple le type de données à manipuler est int.
Le pb c'est que, écrit comme ça, mon code ne traitera que des listes qui manipuleront des int.
Aussi, j'aimerais savoir si il était possible (via une fonction ou un typedef particulier) de définir 2 listes (faisant appel au même code) mais qui manipuleraient chacune une donnée de type différent sans avoir a réécrire 2 fois le code.
En C++ c'est possible avec les templates, y a t-il une équivalence en C ?

Merci
21/07/2006, 11h37
DaZumba

Citation:

Envoyé par tintin72

En C++ c'est possible avec les templates, y a t-il une équivalence en C ?

Non. Le seul moyen d'ecrire du code generique est de manipuler des pointeurs void (void *).
21/07/2006, 11h48
tintin72

Citation:

Non. Le seul moyen d'ecrire du code generique est de manipuler des pointeurs void (void *).

Merci ;) mais est ce que tu pourrais me donner un exemple concret ?
21/07/2006, 11h52
joellel

http://nicolasj.developpez.com/articles/listesimple/
21/07/2006, 11h55
PRomu@ld

Citation:

Non. Le seul moyen d'ecrire du code generique est de manipuler des pointeurs void (void *).

C'est aussi possible en utilisant des macros.
21/07/2006, 14h49
tintin72

Citation:

C'est aussi possible en utilisant des macros.

Pourrais tu me dire comment faire, ou bien me donner un liens sur un exemple ou un tuto ,

Merci;)
21/07/2006, 14h53
Emmanuel Delahaye

Citation:

Envoyé par tintin72

Pourrais tu me dire comment faire, ou bien me donner un liens sur un exemple ou un tuto ,

T'as la flemme de le faire toi même ou quoi ? il faut qu'on te file tout tout cuit ? T'as pas de cerveau ? Fait trop chaud, il a fondu ?

Si tu cherches à vraiment apprendre, le mieux est de nous présenter tes essais. Maintenant si tu veux ne veux rien apprendre mais juste pomper, continue comme ça...
21/07/2006, 15h12
tintin72

Citation:

T'as la flemme de le faire toi même ou quoi ? il faut qu'on te file tout tout cuit ? T'as pas de cerveau ? Fait trop chaud, il a fondu ?
Maintenant si tu veux ne veux rien apprendre mais juste pomper, continue comme ça...

On peut trés bien apprendre en regardant un exemple puis en l'analysant!
Qui te dis que je vais faire un copier/coller tout bête ?
Tu as tout découvert par toi même toi ?
Si oui alors Bravo!! tu es un petit génie, je me demande ce que tu fais sur ce forum.
Excuse moi encore d'avoir sollicité ton incommensurable savoir.
21/07/2006, 15h15
joellel

Tu exagères un peu! Emmanuel a raison en te suggérant d'utiliser Google ou tout autre moteur de recherche pour trouver les infos par toi même.
Celle que je t'ai donnée tout à l'heure, comment crois tu que je l'ai trouvée?D'autant plus qu'on tombe toujours sur des infos intéressantes lors de ce type de recherches ;)
21/07/2006, 15h24
tintin72

Citation:

Tu exagères un peu! Emmanuel a raison en te suggérant d'utiliser Google ou tout autre moteur de recherche

Je l'ai déjà fait figure toi ;) mais je n'ai pas trouvé suffisament d'infos.
De plus ne suis pas un pro du C, et la généricité en C n'est pas vraiment un truc facile à saisir.
Aussi, je ne trouve pas que demander un lien soit une marque de flemmardise
éhontée.
21/07/2006, 15h36
Emmanuel Delahaye

Citation:

Envoyé par tintin72

De plus ne suis pas un pro du C, et la généricité en C n'est pas vraiment un truc facile à saisir.
Aussi, je ne trouve pas que demander un lien soit une marque de flemmardise
éhontée.

Comme jusque là, tu as montré 1 ligne de code, on a des doutes...

http://emmanuel-delahaye.developpez.com/tad.htm
http://emmanuel-delahaye.developpez.com/complog.htm
21/07/2006, 15h41
joellel

Bon, je m'énerve :evilred:
Google vient de me trouver un super tutoriel sur les listes (que je vais garder, d'ailleurs ;) ): http://ilay.org/yann/articles/genericite/

plus un bon cours de C: http://www-id.imag.fr/~svarrett/down...TML/index.html

plus un cours sur les structures de données avec exemple de macros
http://www-lipn.univ-paris13.fr/~bou...iemePartie.pdf
Je m'arrête là car j'ai mieux à faire ;)

Citation:

Bon, je m'énerve

Restes calme;) je l'avais déjà trouvé aussi, mais bon y a encore des trucs qu'il faut que je saisisse.

Citation:

Comme jusque là, tu as montré 1 ligne de code, on a des doutes...

Ok, bon alors voilà le code actuel de ma liste chainée. Je n'ai que le header (les fonctions ne sont pas encore implémentées).
En fait je me suis inspiré d'un (trés bon) exemple de liste en C++, et j'aimerais bien retranscrire ces même fonctionnalité en C (+ la généricité).

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
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
 
#ifndef _LINKEDLIST_H_
#define _LINKEDLIST_H_
#include <stdio.h>
#include <stdlib.h>
 
 
typedef unsigned int UINT;
typedef void* PVOID; //définit un pointeur générique
 
 
typedef struct{
 
    PVOID data;
    struct ELEMENT *next;//pointe sur l'élément suivant
    struct ELEMENT *prev;//pointe sur l'élément précédent
 
} ELEMENT;
 
typedef ELEMENT*  PELEMENT; //définit un pointeur sur une structure ELEMENT
 
typedef struct{
 
   PELEMENT head; //pointe sur le 1er élément
   PELEMENT tail;   //pointe sur le dernier élément
   PELEMENT curr; //pointe sur l'élément courant
   UINT nbElem;  //nombre d'éléments dans la liste
 
} LIST;
 
 
   //MÉTHODES DE MODIFICATION
int addBeg(const PVOID *val, bool mdf); //ajoute ou modifie un (l')élément en début de liste
int addBeg();//ajoute un élément vide en début de liste (surcharge)
int addEnd(const PVOID *val, bool mdf); //ajoute ou modifie un (l')élément en fin de liste
int addEnd();//ajoute un élément vide en fin de liste (surcharge)
int addPos(const PVOID *val, UINT pos, bool mdf);//ajoute ou modifie un (l')élément à la position donnée
int addPos(UINT pos);//ajoute un élément vide à la position donnée (surcharge)
 
void removeBeg(); //retire le 1er élément de la liste
void removeEnd(); //retire le dernier élément de la liste
void removePos(UINT pos); //retire l'élément à la position donnée
void empty();  // vide la liste.
 
       //GESTION DE L'ELEMENT COURANT
 
void setCurrBeg(); //le 1er élément est l'élément courant
void setCurrEnd(); //le dernier élément est l'élément courant
void setCurrPos(UINT pos);//définit l'élément courant à la position donnée
void incrCurr();//incrémente l'élément courant de 1 élément vers la fin de la liste
void decrCurr();//décrémente l'élément courant de 1 élément vers le début de la liste
void setCurr(const TYPE *val); //modifie l'élément courant
 
       //MÉTHODES DE CONSULTATION
 
PVOID consultBeg() const; //retourne la valeur du 1er élément de la liste
PVOID consultEnd() const; //retourne la valeur du dernier élément de la liste
PVOID consultPos(UINT pos) const; //retourne la valeur de l'élément à la position donnée
PVOID consultCurr() const; //retourne la valeur de l'élément courant
int isEmpty() const {return nbElem == 0;} //Retourne 1 si la liste est vide, sinon zéro.
int size() const {return nbElem;}//Retourne le nombre d'éléments présents dans la liste
 
#endif /*_LINKEDLIST_H_*/

21/07/2006, 16h19
Pikwik

Hum,

Pourquoi tu te compliques la vie ? Tu fais ta liste qui prend en donnèes un pointeur void. Après quand tu utilises ta liste (que ce soit une fois ou 40 fois) tu fabriques une structure pour chauq'une de tes listes, et tu fais pointer ton pointeur de donnèes vers des instances(instance est bien le bon mot ?) de cette strcture.

J'utilise toujours les même fichiers .h et .c pour mes listes, et après je fabrique un "manager" qui contient ma structure et toute les fonctions utiles pour ajouter supprimer, qui utilise les fonction de ma liste. Les fonctions du manager sont très rapide à écrire, ca prend 15 minutes en fonction de la complexcité.

Donc si j'ai 4 listes différentes j'ai 1 seul type de liste et 4 managers différents...

J'espère ne m'être pas trop mal exprimé... :aie:
21/07/2006, 16h42
gege2061

Citation:

Envoyé par PRomu@ld

C'est aussi possible en utilisant des macros.

Je serais quand même curieux de connaitre la méthode pour faire ça avec des macro. Tu simule la surcharge de fonctions grâce à sizeof ?
22/07/2006, 13h06
millie

Citation:

Envoyé par gege2061

Je serais quand même curieux de connaitre la méthode pour faire ça avec des macro. Tu simule la surcharge de fonctions grâce à sizeof ?

ça dépend comment la liste est utilisée dans le programme après, mais on peut utiliser (personnellement, je le ferai pas) des #ifdef MACHIN avec à chaque fois des: typedef le_type Element;

Lors de la compilation, il suffit d'ajouter -DMACHIN pour avoir le bon type au bon moment. Mais le problème c'est qu'une fois compilé, la liste n'est utilisable qu'avec un seul type !
22/07/2006, 14h23
tintin72

Citation:

gege2061 a écrit :
Je serais quand même curieux de connaitre la méthode pour faire ça avec des macro. Tu simule la surcharge de fonctions grâce à sizeof ?

http://www.exood4.com/tutorials/arti..._1.php?lang=fr

mais 'faut bien connaitre les macros :aie:
pour l'instant j'ai pas encore tout compris. ;)
22/07/2006, 14h59
PRomu@ld

Citation:

Je serais quand même curieux de connaitre la méthode pour faire ça avec des macro.

Citation:

http://www.exood4.com/tutorials/arti..._1.php?lang=fr

C'est presque de cette manière que j'avais eu l'occasion de faire. C'était un sujet de TP, si j'ai l'occasion de remettre la main dessus je te l'enverrai.

Voici un exemple d'une pile générique. Apres il suffit d'adapter ce modèle aux listes ;)

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
33
34
35
36
37
 
#ifndef PILE_H
#define PILE_H
 
#define PILE_IMPLEMENTATION(type, taille) \
    {\
        type base [taille];\
        type *prochain;\
    }
 
#define PILE_DECLARER(type, ident, taille) \
    struct PILE_IMPLEMENTATION(type, taille) ident
 
#define PILE_DEFTYPE(type, ident, taille) \
    struct ident PILE_IMPLEMENTATION(type, taille);\
    typedef struct ident ident
 
#define PILE_TAILLE(ident)  \
    (sizeof(ident).base/sizeof(ident).base[0])
 
#define PILE_LIMITE(ident) \
    ((ident).base + PILE_TAILLE((ident)))
 
#define PILE_INIT(ident) \
    (ident).prochain = ((ident).base)
 
#define EMPILER(ident,e)     (*(ident).prochain++ = (e))
#define DEPILER(ident)       (*--(ident).prochain)
 
#define PILE_VIDE(ident) \
    ((ident).prochain == (ident).base)
#define PILE_PLEINE(ident) \
    ((ident).prochain >= PILE_LIMITE(ident))
 
#define PILE_SOMMET(ident) (*((ident).prochain-1))
 
#endif  /* PILE_H */

Voilà, si ça peut aider :aie:

Ce code est issue du livre "Méthodologie de la Programmation en C".

22/07/2006, 19h23
Emmanuel Delahaye

Citation:

Envoyé par _kal_

Voici un exemple d'une pile générique. Apres il suffit d'adapter ce modèle aux listes ;)
<...>
Voilà, si ça peut aider :aie:

Bien garder en tête que ident ne doit pas être un pointeur (ou alors déréférencé : *p, voire multiplié par une nombre d'éléments : *p * n, enfin, ça dépend des cas, bref, c'est pas évident). Je préfère la méthode du void *...
22/07/2006, 20h29
_kal_

Citation:

Envoyé par Emmanuel Delahaye

Bien garder en tête que ident ne doit pas être un pointeur (ou alors déréférencé : *p, voire multiplié par une nombre d'éléments : *p * n, enfin, ça dépend des cas, bref, c'est pas évident). Je préfère la méthode du void *...

Tout à fait, sinon l'utilisation de l'opérateur "." serait illégal. Je n'ai pas eu l'occasion d'étudier la forme avec des pointeurs génériques, mais elle semble être moins difficile à mettre en œuvre (je trouve l'écriture de macros moins lisible, question de gouts...)
22/07/2006, 20h57
tintin72
Ceci dit je n'arrive pas bien à saisir comment utiliser une liste avec le pointeur void*.
Dans le main de l'exemple
http://nicolasj.developpez.com/articles/listesimple/
la valeur des éléments est passé via un tableau (2 dim) de char
Code:

1 2 3 4 5 6 7 char text[][6] = { "Hello", " ", "World", "!" }; for (i = 0; i < 4; i++) { sll_insert (p_sll, text[i]); }
ce qui voudrait dire que si je veux stoker des int dans ma liste il faut d'abord que je déclare une variable int (ou un tableau de int) , que je lui affecte une valeur, puis qu'ensuite je procède à l'insertion ?
Je ne vois pas trop l'intérêt s'il faut à chaque fois déclarer une variable pour chaque élément.
Pour une liste générique je verrais plutôt une insertion du genre:
Code:

1 2 sll_insert (p_sll, 24); //ajoute un élément dans la liste et y stocke la valeur 24
plus dans l'esprit STL.
Mais bon, je n'ai peut être pas bien compris l'utilisation du pointeur générique.
22/07/2006, 22h48
Emmanuel Delahaye
Citation:

Envoyé par tintin72

Ceci dit je n'arrive pas bien à saisir comment utiliser une liste avec le pointeur void*.
<...>Mais bon, je n'ai peut être pas bien compris l'utilisation du pointeur générique.

Le pointeur contient l'adresse des données de l'utilisateur. C'est tout. Le mécanisme de gestion de la liste ne s'occupe jamais des données elle-même (il n'en a strictement rien à faire). Il se contente de stocker l'adresse et de la retourner si nécessaire.

L'utilisateur est complètement responsables de la mémoire des données (après tout, ce sont les siennes...) et de leur persistance (durée de vie).

Autre avantage, dans le mécanisme de gestion de la liste, les données ne sont jamais recopiées.

http://emmanuel-delahaye.developpez.com/clib.htm
Module GLL :
Code:

1 2 3 4 5 6 7 struct node { struct node *p_next; struct node *p_prev; void const *p_data; };
23/07/2006, 00h33
David.Schris

Citation:

Envoyé par Emmanuel Delahaye

Le pointeur contient l'adresse des données de l'utilisateur. C'est tout. Le mécanisme de gestion de la liste ne s'occupe jamais des données elle-meêm (il n'en a strictement rien à faire). Il se contente de stocker l'adresse et de la retourner si nécessaire.

[...]

Autre avantage, dans le mécanisme de gestion de la liste, les données ne sont jamais recopiées.

[...]

Encore un autre avantage : cela permet de créer des listes qui contiennent (chacune) des données de types (et tailles) différents (i.e. : on peut enfin mélanger les torchons et les serviettes :) ). A utiliser avec parcimonie...
23/07/2006, 01h22
Emmanuel Delahaye

Citation:

Envoyé par David.Schris

Encore un autre avantage : cela permet de créer des listes qui contiennent (chacune) des données de types (et tailles) différents (i.e. : on peut enfin mélanger les torchons et les serviettes :) ). A utiliser avec parcimonie...

Structures avec selecteur (ou union) recommandées.
23/07/2006, 01h42
LLB

Citation:

Envoyé par David.Schris

Encore un autre avantage : cela permet de créer des listes qui contiennent (chacune) des données de types (et tailles) différents.

Oui, mais c'est un défaut en même temps.
Ca affaiblit le système de typage (déjà qu'il est pas très fort à la base), et empêche la détection de nombreuses erreurs à la compilation. Ca demande donc une plus grande rigueur.

L'autre problème soulevé par tintin, c'est si l'on veut manipuler un type simple (genre les entiers), on doit systématiquement passer par des variables.

Je préfère donc éviter tant que possible de passer par le void*, et je conseillerais plutôt de passer par des macros (mais c'est sûrement aussi une question).
23/07/2006, 01h48
Emmanuel Delahaye

Citation:

Envoyé par LLB

Oui, mais c'est un défaut en même temps.
Ca affaiblit le système de typage (déjà qu'il est pas très fort à la base), et empêche la détection de nombreuses erreurs à la compilation. Ca demande donc une plus grande rigueur.

C'est sûr, le C , "c'est pas un langage de tapettes"... (humour!)
23/07/2006, 02h25
David.Schris

Citation:

Envoyé par Emmanuel Delahaye

Citation:

Envoyé par LLB

Oui, mais c'est un défaut en même temps.
Ca affaiblit le système de typage (déjà qu'il est pas très fort à la base), et empêche la détection de nombreuses erreurs à la compilation. Ca demande donc une plus grande rigueur.

L'autre problème soulevé par tintin, c'est si l'on veut manipuler un type simple (genre les entiers), on doit systématiquement passer par des variables.

Je préfère donc éviter tant que possible de passer par le void*, et je conseillerais plutôt de passer par des macros (mais c'est sûrement aussi une question).

C'est sûr, le C , "c'est pas un langage de tapettes"... (humour!)

@ED : :lol:

@LLB :
"Oui, mais c'est un défaut en même temps." => pas si c'est un besoin.

"Ca demande donc une plus grande rigueur." => oui, d'où "A utiliser avec parcimonie..." dans mon message.

"L'autre problème soulevé par tintin, c'est si l'on veut manipuler un type simple (genre les entiers), on doit systématiquement passer par des variables." => si par "passer par des variables" tu veux dire "déclarer une variable par élément de liste", alors : non, ce n'est pas systématiquement nécessaire (mais implique alors de créer une copie des valeurs insérées/ajoutées).

"mais c'est sûrement aussi une question" => de goût, un peu...de besoin, surtout.

"Ca affaiblit le système de typage (déjà qu'il est pas très fort à la base), et empêche la détection de nombreuses erreurs à la compilation." => oui et non.
Imagines que tu aies une librairie de liste générique (avec une fonction "BOOL ajouterAListe(t_MonSuperTypeListe l, void *elementAAjouter);").
Tu vas écrire un programme qui va créer des listes avec des trucs de type A et d'autres de type B dans la même liste.
Dans ce cas, la première chose à faire, si cela n'a pas déjà été fait dans la librairie (typiquement pour tous les types de base cela devrait être déjà fait), est de créer des fonctions qui serviront d'interface pour les types A et B ("BOOL ajouter_A_AListe(t_MonSuperTypeListe l, A elementDeTypeA);" et "BOOL ajouter_B_AListe(t_MonSuperTypeListe l, B elementDeTypeB);").
Ensuite tu peux écrire ton programme sans JAMAIS appeler la fonction générique mais en appelant toujours les fonctions qui servent d'interface.
Maintenant, essayes de déclarer une variable V de type A et d'écrire "retour = ajouter_B_AListe(l, V);"...si ton compilateur ne râle pas parce que le type est mauvais : changes-en.
Enfin si la création de ces fonctions-interfaces paraît rebutante, il y a moyen d'alléger un peu les choses en créant une macro pour en simplifier l'écriture...

J'ai pas dit de bêtise ? Je peux aller me coucher ?
23/07/2006, 11h05
Pikwik

Citation:

Oui, mais c'est un défaut en même temps.
Ca affaiblit le système de typage (déjà qu'il est pas très fort à la base), et empêche la détection de nombreuses erreurs à la compilation. Ca demande donc une plus grande rigueur.

D'où l'interet de créer un "manager" avec des fonctions qui s'occupe du typage pour l'enregistrement et la récupération des donnèes.
24/07/2006, 02h29
johnnyjohnny

Essaye avec queue.h (tu le chopes dans les sources d'un unix libre genre netbsd).

Ca te permet de créer toute sorte de listes et d'opérations dessus. Tu définis ta structure et ça marche.