FILE avec une liste chaînée à doubles pointeurs

Version imprimable

Bonsoir,
j'essaye d'écrire un programme en c qui contient les fonctions de base de manipulation d'une File .Comme le titre l'indique le modèle que j'essaye de développer consiste à une liste chaînée à double pointeurs c'est à dire un pointeur sur la cellule suivante ,un pointeur sur la cellule précédente et la tete de la liste chaînée pointe sur la queue de la File tout en considérant le pointeur du début de la File égale à NULL et le pointeur de fin de File égale à NULL .
Apres le Build et le Run l'exécutable cesse de fonctionner .
Pièce jointe 426030
Pièce jointe 426034
Pourriez vous m'aider à trouver le probleme s'il vous plait et merci.

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
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
99
100
101
102
103
#include <stdio.h>
#include <stdlib.h>
typedef struct Element Element;
struct Element
{
    int data;
    Element* prec;
    Element* suiv;
};
 
typedef struct File File ;
struct File
{
    Element *premier;
};
void init(File *ff)
{
    Element *nouveau=malloc(sizeof(*nouveau));
    ff->premier=nouveau;
    nouveau->prec=NULL;
    nouveau->suiv=NULL;
}
void enfiler(File *ff,int a)
{
    Element *nouveau=malloc(sizeof(*nouveau));
    if ((ff==NULL) || (nouveau==NULL))
    {
        exit(EXIT_FAILURE);
    }
    else if (ff->premier == NULL)
    {
        init(ff);
        ff->premier->data=a;
    }
    else
    {
        ff->premier->prec=nouveau;
        nouveau->suiv=ff->premier;
 
        ff->premier=nouveau;
        nouveau->prec=NULL;
        nouveau->data=a;
    }
}
int defiler(File *ff,int *x) //retourne 0 si c'est impossible de défiler 1 sinon
{
    Element *adefile=malloc(sizeof(*adefile));
    if ((ff==NULL)||(adefile==NULL))
    {
        exit(EXIT_FAILURE);
    }
    else if (ff->premier ==NULL)
    {
        return 0;
    }
    else
    {    adefile=ff->premier;
        while (adefile->suiv !=NULL)
        {
            adefile=adefile->suiv;
        }
        *x=adefile->data;
        adefile->prec->suiv=NULL;
        free(adefile);
        return 1;
    }
}
void afficher(File *ff)
{
   Element *actuel=malloc(sizeof(*actuel));
  if ((ff=NULL)||(actuel==NULL))
  {
      exit(EXIT_FAILURE);
  }
  actuel=ff->premier;
  while (actuel->suiv!= NULL)
  {
      printf("\n%d",actuel->data);
      actuel=actuel->suiv;
  }
}
int main()
{
    File *f=malloc(sizeof(*f));
    init(f);
    enfiler(f,5);
    enfiler(f,4);
    enfiler(f,369);
    enfiler(f,25);
    enfiler(f,18);
    enfiler(f,125);
 
    afficher(f);
    int a,b,z,y;
    z=defiler(f,&a);
    y=defiler(f,&b);
 
    afficher(f);
    printf("a=%d",a);
    printf("b=%d",b);
 
    return 0;
}

10/11/2018, 22h04
gerald3d

Bonsoir.

Déjà il me semble qu’il y a une fuite mémoire dans enfiler ();.

Tu alloues «*nouveau*». Si ff->premier=NULL alors «*nouveau*» ne sert à rien et est perdu par la même occasion.
D’ailleurs on peut faire la même remarque dans défiler (); pour «*adefile*».
10/11/2018, 22h17
kerrons

Nouveau dans enfiler et adefile dans défiler jouent respectivement le rôle de cellule complémentaire et intermédiaire dans les deux fonction plus précisément dans "else". J'ai allouer les deux pointeurs au début pour pouvoir faire le test de réussite d'allocation dans "if " et tout cela pour éviter le type d'erreur qu'on puisse avoir si nouveau= NULL dans nouveau->prec=NULL.
11/11/2018, 08h37
Matt_Houston

Cela ne change rien à la validité de la remarque : tu omets de stocker une adresse dont tu as la responsabilité. Tu fais ton allocation trop tôt, dans la séquence de contrôle commune, alors que tu ne devrais l'effectuer que dans la branche pertinente.

D'ailleurs tu malloc beaucoup trop souvent : à quoi peut bien servir une allocation dynamique lorsque l'on retire un élément de la file ? Lorsque l'on en affiche le contenu ? Dans main (crée une variable sur la pile) ? Tu devrais avoir un seul appel à malloc dans tout le programme, à la rigueur deux si tu tiens à cloisonner le traitement d'init.
11/11/2018, 08h46
gerald3d

Citation:

Envoyé par kerrons

Nouveau dans enfiler et adefile dans défiler jouent respectivement le rôle de cellule complémentaire et intermédiaire dans les deux fonction plus précisément dans "else". J'ai allouer les deux pointeurs au début pour pouvoir faire le test de réussite d'allocation dans "if " et tout cela pour éviter le type d'erreur qu'on puisse avoir si nouveau= NULL dans nouveau->prec=NULL.

Je comprends que tu veuilles faire une «*économie*» en ne faisant qu’un if mais il n’empeche que tu as une fuite mémoire !
Je poursuis mes commentaires. Faire un exit(); dans une fonction n’est pas très «*propre*». Il vaudrait mieux que ta fonction retourne un booléen qui indiquerait la réussite ou l’echec de son exécution.

Pour finir, dans la fonction main(); tu peux faire l’economie d’une allocation dans le tas pour f. Un simple File f; suffit ici. Tu transmets ensuite son pointeur à tes différentes fonctions.
11/11/2018, 09h40
Sve@r
Bonjour

gerald3d a parfaitement raison dans toutes ses remarques. Tu alloues avant de vérifier si l'allocation est nécessaire et donc si ce n'est pas le cas tu perds le maillon alloué.
De même comme il le dit ton allocation de "File" dans le main() est totalement inutile (comme d'une manière générale toute allocation d'une zone de taille connue quand on écrit le code). D'autant plus que tu ne libères pas cette allocation. Donc de fait ton main() pourrait s'écrire plus simplement ainsi
Code:

1 2 3 4 5 6 7 8 9 int main() { File f; init(&f); enfiler(&f,5); enfiler(&f,4); enfiler(&f,369); ... (et tout le reste à l'avenant) }
Sinon ici un exemple complet de liste chainée correspondant exactement à ce que tu cherches à faire => liste doublement chainée avant/arrière avec tête de liste contenant un pointeur sur le premier et un sur le dernier.
11/11/2018, 11h50
kerrons

Merci pour vos remarques j'essayerais d'améliorer le programme et je vous tiendrais au courant des modifications et du résultat .

Apres modification le programme fonctionne mais j'ai une boucle infinie apparemment c'est la boucle while dans afficher .Je ne comprend pas pourquoi la condition d’arrêt n'est pas atteinte.

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
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
99
100
101
102
103
104
105
 
#include <stdio.h>
#include <stdlib.h>
typedef struct Element Element;
struct Element
{
    int data;
    Element* prec;
    Element* suiv;
};
 
typedef struct File File ;
struct File
{
    Element *premier;
};
void init(File *ff)
{
    Element nouveau;
    ff->premier=&nouveau;
    nouveau.prec=NULL;
    nouveau.suiv=NULL;
}
int enfiler(File *ff,int a)//retourn 0 si c'est impossible d'enfiler 1 sinon
{
 
    if (ff==NULL)
    {
        return 0;
    }
    else if (ff->premier == NULL)
    {
        init(ff);
        ff->premier->data=a;
        return 1;
    }
    else
    {
        Element nouveau;
        ff->premier->prec=&nouveau;
        nouveau.suiv=ff->premier;
 
        ff->premier=&nouveau;
        nouveau.prec=NULL;
        nouveau.data=a;
        return 1;
    }
}
int defiler(File *ff,int *x) //retourne 0 si c'est impossible de défiler 1 sinon
{
 
    if (ff==NULL)
    {
        return 0;
    }
    else if (ff->premier ==NULL)
    {
        return 0;
    }
    else
    {
        Element adefile;
        adefile=*(ff->premier);
        while (adefile.suiv != NULL)
        {
            adefile=*(adefile.suiv);
        }
        *x=adefile.data;
        adefile.prec->suiv=NULL;
 
        return 1;
    }
}
int  afficher(File *ff)//retourn 0 si c'est impossible dafficher 1 sinon
{
   Element actuel;
  if (ff==NULL)
  {
      return 0;
  }
  actuel=*(ff->premier);
  while (actuel.suiv != NULL)
  {
      printf("\n%d",actuel.data);
      actuel=*(actuel.suiv);
  }
  return 1;
}
int main()
{   int u;
    File f;
    init(&f);
    u=enfiler(&f,5);
    u=enfiler(&f,4);
    u=enfiler(&f,369);
    u=enfiler(&f,25);
    u=enfiler(&f,18);
    u=enfiler(&f,125);
    u=afficher(&f);
 
 
 
 
    return 0;
}

Citation:
Envoyé par kerrons
Apres modification le programme fonctionne mais j'ai une boucle infinie apparemment c'est la boucle while dans afficher .Je ne comprend pas pourquoi la condition d’arrêt n'est pas atteinte.
Code:

1 2 3 4 5 6 7 void init(File *ff) { Element nouveau; ff->premier=&nouveau; nouveau.prec=NULL; nouveau.suiv=NULL; }
Ici grosse bêtise : tu récupères l'adresse d'une variable locale, adresse détruite (ou réutilisée pour autre chose) quand la fonction se termine. Donc au final t'as stocké dans ta file une adresse contenant n'importe quoi.

Supprimer le malloc dans le main c'était bien vu que quand le main se termine le programme se termine avec et donc t'as alors plus besoin de la variable "f" ni de son emplacement mémoire... mais supprimer l'allocation du nouveau maillon c'était moins bien...

Accessoirement je ne vois pas pourquoi l'initialisation de la liste (liste pour l'instant vide) implique l'allocation d'un maillon (maillon servant à stocker quoi ???)
Il faut programmer atomique. Une fonction d'initialisation initialise et ne fait rien d'autre ; tandis qu'une fonction d'insertion insère et en fait rien d'autre non plus. Tu devrais même écrire une fonction de création pour créer (allouer) le maillon et le remplir mais à la rigueur on peut laisser pour l'instant la création dans l'insertion.
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 File *initFile(File *ff) { if (ff == NULL) return NULL; ff->premier=NULL; return ff; } Element *enfiler(File *ff, int a) { if (ff == NULL) return NULL; Element *nouveau; nouveau=malloc(sizeof(*nouveau)); if (nouveau == NULL) return NULL; nouveau->data=a; nouveau->suiv=ff->premier; ff->premier=nouveau; return nouveau; } void afficherFile(File *ff) { if (ff == NULL) return; Element *actuel; for (actuel=ff->premier; actuel != NULL; actuel=actuel->suiv) { printf("%d\n",actuel->data); } } void freeFile(File *ff) { if (ff == NULL) return; Element *actuel; while (ff->premier) { actuel=ff->premier; ff->premier=ff->premier->suiv; free(actuel); } } int main() { File f; initFile(&f); enfiler(&f,5); enfiler(&f,4); enfiler(&f,369); enfiler(&f,25); enfiler(&f,18); enfiler(&f,125); afficherFile(&f); freeFile(&f); return 0; }