Vider liste chainée, problème

**hunter99** · 23/03/2007, 18h27

Slt j’ai ecrit une fct pour effacer une liste chainée de la memoire mais ça coince, en effet il y a une erreur obscure DAMAGE :after normal block(#42) .
J’ai cherché avec google mais j’ai rien trouvé concernant cette erreur.
Voila le code et merci pour votre aide.

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
typedef struct noeud
{ 
	int val;
	struct noeud* svt;
}noeud;
void vider_liste(noeud **n)
{
	noeud *temp=*n;
	while(n!=NULL)
	{
		temp=*n;
		(*n)=(*n)->svt;
		free(temp);
	}
}

**Sanguko** · 23/03/2007, 18h31

Code :

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

1
2
while(*n!=NULL)

**Thierry Chappuis** · 23/03/2007, 18h34

Envoyé par hunter99

Slt j’ai ecrit une fct pour effacer une liste chainée de la memoire mais ça coince, en effet il y a une erreur obscure DAMAGE :after normal block(#42) .
J’ai cherché avec google mais j’ai rien trouvé concernant cette erreur.
Voila le code et merci pour votre aide.

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
typedef struct noeud
{ 
	int val;
	struct noeud* svt;
}noeud;
void vider_liste(noeud **n)
{
	noeud *temp=*n;
	while(n!=NULL)
	{
		temp=*n;
		(*n)=(*n)->svt;
		free(temp);
	}
}

Le problème est dans la condition:

Code :

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

1
2
3
4
while (*n != NULL)
{
    /* ... */
}

Ta fonction devient donc:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
void vider_liste(noeud **n)
{
    if (n != NULL && *n != NULL)
    {
        noeud *temp=*n;
	while(*n != NULL)
	{
	    temp=*n;
	    (*n)=(*n)->svt;
	    free(temp);
	}
    }
}

Thierry

**hunter99** · 23/03/2007, 19h16

ça ne marche pas ! j'ai le meme probleme,est ce que ça fonctionne chez vous ?

**Mat.M** · 23/03/2007, 20h53

le problème c'est est-ce que n==NULL dans le while ?
Est-ce qu'à un moment il est affecté à NULL dans le code ?

**hegros** · 23/03/2007, 21h30

Envoyé par hunter99

ça ne marche pas ! j'ai le meme probleme,est ce que ça fonctionne chez vous ?

Dans ce cas il faut mettre la casquette avec la siréne sur la tête et passer en pas à pas en mode debugage pour voir ce qu'il se passe. Mets un point d'arrêt à l'entrée de ta fonction et profite-en pour te faire un sandwich (la nuit s'annonce longue...)

**mchk0123** · 23/03/2007, 21h37

Comme cela ne semble toujours pas corriger ton problème de message d'erreur à l'exécution, est-ce que cela ne vient pas du fait que ta fonction vide_liste s'écrive :

Code :

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

1
2
3
void vider_liste(noeud **n) {
...
}

Or comme dans le code de cette fonction, la valeur '*n' est modifiée, la variable passée en argument de la fonction est elle aussi modifiée (ce type d'erreur s'appelle un "effet de bord").

Autrement dit, il n'est plus possible d'utiliser cette variable avec n'importe quelle fonction de traitement d'une liste. Ainsi :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
int main() {
noeud *liste;
 
  ...
  // Je crée ma liste dont la tête est stockée dans liste
  ...
  afficher_liste(&liste); // là aucun pb.
  vider_liste(&racine);  // aprés l'appel, la variable liste pointe sur n'importe quoi (plus précisement sur NULL)
 
  afficher_liste(&liste)  // là il y a une erreur à l'exécution
}

**Trap D** · 23/03/2007, 22h07

Pour désallouer la liste correctement, il faut qu'elle soit allouée correctement, as-tu toujours bien initialisé correctement les (*n)->svt et en particulier le dernier car s'il n'est pas mis à NULL, bonjours les dégats ...
Au point de vue algo, on fait plutôt comme ça d'habitude

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
void vider_liste(noeud **n)
{
    if (n != NULL )
    {
	while(*n != NULL)
	{
	    noeud *temp=(*n)->svt;
	    free(*n);
           *n = temp;
	}
    }
}

**hegros** · 23/03/2007, 22h09

mchk0123 :

Normalement dans affiche_liste il devrait traiter le cas où le pointeur est NULL (liste vide), d'ailleurs c'est une méthode pour savoir que la liste est effectivement vide.

**mchk0123** · 23/03/2007, 22h11

Bah j'ai pris affiche_liste comme exemple, ça aurais put être n'importe quelle autre fonction.
Et puis même avec affiche_liste, quand on n'est pas trés à l'aise avec le C dés fois on ne penses pas à tous les cas possibles.

**hunter99** · 24/03/2007, 13h54

re , j'ai lancé debuggué la fonction et elle plante exactement dans le free() dans tous les codes que j'ai essayé , le "DAMAGE: after normal (#50)" affiche l'adresse de la variable temp .
est ce que vous avez une ptite idée de la cause du bug

?

**Emmanuel Delahaye** · 24/03/2007, 14h34

Envoyé par hunter99

est ce que vous avez une ptite idée de la cause du bug

?

Montre le code qui créée la liste.

Pourquoi passer l'adresse du pointeur, vu qu'il n'est jamais modifié ?

Maintenant, j'aimerais avoir le code qui ajoute un noeud dans la liste...

Ceci fonctionne : (EDIT)

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
 
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
 
typedef struct noeud
{
   int val;
   struct noeud *svt;
}
noeud;
 
void voir_liste (noeud * n)
{
   while (n != NULL)
   {
      printf ("%d -> ", n->val);
      n = n->svt;
   }
   printf ("NIL\n");
}
 
noeud *ajouter_liste (noeud * n, int val)
{
   noeud *new = malloc (sizeof *new);
   if (new != NULL)
   {
      new->val = val;
      new->svt = NULL;
      if (n == NULL)
      {
         n = new;
      }
      else
      {
         noeud *p = n;
         while (p->svt != NULL)
         {
            p = p->svt;
         }
         p->svt = new;
      }
   }
   return n;
}
 
/* EDIT : forçage de la tête (de noeud, mouarf!) à NULL */
void vider_liste (noeud **pn)
{
   noeud *n = *pn;
   while (n != NULL)
   {
      noeud *temp = n;
      n = n->svt;
      free (temp);
   }
   *pn = NULL;
}
 
int main (void)
{
   noeud *n = NULL;
 
   n = ajouter_liste (n, 1);
   n = ajouter_liste (n, 2);
   n = ajouter_liste (n, 3);
 
   voir_liste (n);
 
   vider_liste (&n);
 
   assert (n == NULL);
 
   return 0;
}

**hunter99** · 24/03/2007, 15h13

Pourquoi passer l'adresse du pointeur, vu qu'il n'est jamais modifié ?

euh j'ai pas bien saisie ta fonction vider normalement lrsq on va modifier la liste on doit lui passer un noeud** ?

**Emmanuel Delahaye** · 24/03/2007, 15h20

Envoyé par hunter99

euh j'ai pas bien saisie ta fonction vider normalement lrsq on va modifier la liste on doit lui passer un noeud** ?

Rien vu de tel dans ton code, alors j'ai zappé.

**hunter99** · 24/03/2007, 17h12

Rien vu de tel dans ton code, alors j'ai zappé.

hein ?

**Emmanuel Delahaye** · 24/03/2007, 17h23

Envoyé par hunter99

hein ?

Je n'ai pas vu que tu modifiais n, j'ai donc supprimé une indirection (une * quoi). J'aime quand c'est simple. Le code est généralement moins buggé quand il est simple...

**mchk0123** · 24/03/2007, 17h35

Et bien si, justement sa fonction modifie la variable n passé en paramètre :

Code :

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

(*n)=(*n)->svt;

Supposons que tu appelles la fonction comme çà :

Code :

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

1
2
3
noeud *liste;
...
vider_liste(&liste);

Et bien dans le cas de la fonction écrite par Emmanuel, aprés l'appel à vider_liste(), liste pointe sur une zone mémoire qui n'est plus allouée.
Alors que la fonction de hunter99, liste pointe sur NULL. Ce qui est plus propre.

**Emmanuel Delahaye** · 24/03/2007, 18h00

Envoyé par mchk0123

Et bien si, justement sa fonction modifie la variable n passé en paramètre :

Code :

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

(*n)=(*n)->svt;

OK. Vu. Je corrige.

**koala01** · 25/03/2007, 06h55

Salut,

Envoyé par Emmanuel Delahaye

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
 
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
 
(snip)
noeud *ajouter_liste (noeud * n, int val)
{
   noeud *new = malloc (sizeof *new);
   if (new != NULL)
   {
      new->val = val;
      new->svt = NULL;
      if (n == NULL)
      {
         n = new;
      }
      else
      {
         noeud *p = n;
         while (p->svt != NULL)
         {
            p = p->svt;
         }
         p->svt = new;
      }
   }
   return n;
}
(snip)

Personnellement, je modifierais meme un tout petit peu le code de cette fonction bien précise en de manière à pouvoir ajouter un élément en n'importe quelle position (valide) de la liste...

La seule différence, c'est qu'il s'agira de trouver l'élément apres lequel le nouveau doit etre ajouté avant de d'appeler la fonciton

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
 
noeud *ajouter_liste (noeud * n, int val)
{
   noeud *new = malloc (sizeof *new);
   if (new != NULL)
   {
      new->val = val;
      if (n == NULL)
      {
         new->svt=NULL;
         n = new;
      }
      else
      {
          new->svt=n->svt;
          n->svt=new;
      }
   }
   return n;
}

A mon gout, étant donné qu'on parle de liste et non de file, il faut prévoir la possiblité d'un tri (ce qui fait toute la différence entre une file et une liste

) et la modification proposée en tient compte

@Emmanuel==>Evidemment, j'ergotte un peu sur les termes... mais tu y es toi meme généralement fort attentif