Listes itératives, relatives, recursives et Makefile en C

Version imprimable

03/12/2006, 14h54
mathieumadrid

1 pièce(s) jointe(s)

Listes itératives, relatives, recursives et Makefile en C
Bonjour,

Je suis en train de faire des listes en C (listes itératives, relatives et récursives).
J'ai fait les listes itératives et relatives. Ces listes sont composées d'éléments que l'utilisateur pourra insérer par la suite dans ses tests. Moi, je définis un élément comme ceci:

Code:

typedef char* ELEMENT;

Dans mes fichiers de test, je fais par exemple:
Code:

1 2 ELEMENT e1 = "1"; insererFin(liste,&e1);
... et ça marche.
Malgré tout, je ne pense pas que l'utilisateur puisse changer le type de l'élément. Par exemple, si on veut mettre des entiers ou des floats dans la liste; comment faire ?

Cependant, on nous impose de faire comme ceci (c'est un devoir d'école):

Code:

typedef char ELEMENT;

Il faut également faire des casts (char*) dans les fonctions qui utilisent ELEMENT*. Est-ce qu'avec cette méthode, on pourra insérer des éléments de n'importe quel type dans les listes ? Si oui, comment faire dans les fichiers de test ? et dans les fichiers sources (car je crois que ça change 2 ou 3 trucs) ?

Sinon, pour tester mes listes, j'ai fait un Makefile. Celui-ci marche mais il a un comportement très bizarre. C'est à dire que je suis obligé de mettre -rm -f *.o pour qu'il puisse refaire les objets ensuite ! Il m'indique des alertes très louches. Y a-t-il un problème dans le Makefile (j'ai un autre Makefile qui s'occupe des sources et des librairies et il marche parfaitement).

Enfin, j'ai des fonctions detruire dans iterative.c et relative.c qui doivent faire le ménage (free). Celle de iterative.c me semble correcte (je ne suis pas sûre) mais celle de relative.c me pose des problèmes. Comment éliminer les cellules d'une liste relative doublement chaînée ?

Voilà, je vous laisse mon projet si vous voulez le voir ou le tester...

merci
03/12/2006, 23h32
Emmanuel Delahaye
Citation:
Envoyé par mathieumadrid

Ces listes sont composées d'éléments que l'utilisateur pourra insérer par la suite dans ses tests. Moi, je définis un élément comme ceci:

Code:

typedef char* ELEMENT;

Dans mes fichiers de test, je fais par exemple:

Code:

1 2 ELEMENT e1 = "1"; insererFin(liste,&e1);

... et ça marche.
OK.

Citation:

Malgré tout, je ne pense pas que l'utilisateur puisse changer le type de l'élément. Par exemple, si on veut mettre des entiers ou des floats dans la liste; comment faire ?

un char * peut stocker l'adresse d'un objet d'un autre type. C'est un peut goret, mais ça marche. Il faut jouer des cast. Attention, la donnée dont on met l'adresse dans le pointeur doit être persistante (statique ou allouée).

Ce serait plus propre si le type était void *.

Code:

typedef void* ELEMENT;

mais dans tous les cas, je n'aime pas qu'on cache le fait qu'on a affaire à un pointeur. (même pas de 'P' dans l'identificateur)...

Citation:

Cependant, on nous impose de faire comme ceci (c'est un devoir d'école):

Code:

typedef char ELEMENT;

T'est sûr ? Si oui, change d'école. Et vite. Un pointeur n'est pas compatible avec un char.

Salut,

Délosé, mais je n'arrive pas à télécharger ton fichier rar... donc je travaille un peu à l'aveuglette...

Dés qu'on parle de liste, j'ai tendance à penser "structure de liste (simplement ou doublement, selon le cas) chainée"...

Est-ce de cela qu'il s'agit :question:

Si oui, la structure idéale se fait sous la forme de

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
/*pour trouver ton ELEMENT*/
typedef char ELEMENT; /*si tu veux un int, il suffit de char en int ;)*/
/*La structure en elle meme */
typedef struct SListe
{
    ELEMENT elem;
    struct SListe *Suivant;
    /* éventuellement, si on parle d'une liste doublement chainée
     *   (qu'on doit parcourrir dans les deux sens)
     * struct SListe*Precedent;
     */
}Liste;

Avec ca, tu as la base pour travailler... Soit en "statique", soit en dynamique (ce qui est peut etre préférable)

En statique, cela fonctionnerait sous la forme de

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
 
int main(int argc, char *argv[])
{
    Liste F1={'b',NULL};
    Liste F2={'o',NULL};
    Liste F3={'n',NULL};
    Liste F4={'j',NULL};
    Liste F5={'o',NULL};
    Liste F6={'u',NULL};
    Liste F7={'r',NULL};
    Liste *temp=NULL;
    F1.Suivant=&F2;
    F2.Suivant=&F3;
    F3.Suivant=&F4;
    F4.Suivant=&F5;
    F5.Suivant=&F6;
    F6.Suivant=&F7;
    temp=&F1;
    while(temp!=NULL)
    {
         printf("%c",temp->elem);
         temp=temp->Suivant;
    }
    return 0;
}

En gestion dynamique, cela pourrait prendre la forme de (c'est un exemple, d'autres solutions sont envisageables ;)

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
 
Liste* Ajout(Liste *actuel, ELEMENT val);
/*une fonction pour la libération (également récursive)
   @arg élément de la liste */
void Liberer(Liste *actuel);
/*La fonction principale */
int main(int argc, char *argv[])
{
    Liste *PTemp=NULL;
    Liste *PFinal=Ajout(NULL,'b');
    Ajout(PFinal,'o');
    Ajout(PFinal,'n');
    Ajout(PFinal,'j');
    Ajout(PFinal,'o');
    Ajout(PFinal,'u');
    Ajout(PFinal,'r');
    PTemp=PFinal;
    while(PTemp!=NULL)
    {
         printf("%c",PTemp->elem);
         PTemp=PTemp->Suivant;
    }
    Liberer(PFinal);
    PFinal=NULL;
}
Liste * Ajout(Liste *actuel,ELEMENT val)
{
    Liste *nouveau;
    if(actuel==NULL)
    {
        nouveau=malloc(sizeof(Liste));
        if(nouveau!=NULL)
        {
            nouveau->Suivant=NULL;
            nouveau->elem=val;
        }
    }
    else
    {
        actuel->Suivant=Ajout(actuel->Suivant,val);
        return nouveau=actuel;
    }
        return nouveau;
}
void Liberer(Liste* actuel)
{
    if(actuel->Suivant!=NULL)
    {
        Liberer(actuel->Suivant);
    }
    /* la ligne suivante est plus là par habitude qu'autre chose ;) */
    actuel->Suivant=NULL;
    free(actuel);
}

Evidemment, les boucles d'affichages ne sont là que pour montrer le résultat...

Elle devront en tout état de cause etre modifiée en fonction du type aliasé par ELEMENT;)