Erreur de segmentation

Version imprimable

Bonjour,

quand je compile ce programme:

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
Liste enlister (Liste liste, int v){
  if (estListeVide (liste)){
      liste->valeur=v;
      liste->lien=NULL;
      return liste;
    }
  else {
    if (estElementListe (liste,v)){
      printf ("L'entier %d est deja present\n", v);
      return liste;
    }
    else {
      Liste ptrcourant=liste;
      Liste ptrprecedent;
      while (ptrcourant !=NULL && (v>(ptrcourant->valeur))){
        ptrprecedent=ptrprecedent;
        ptrcourant=(ptrcourant->lien);
      }
      Element newelement;
      newelement.valeur=v;
      newelement.lien=ptrcourant;
      ptrprecedent->lien = &newelement;
      return liste;
    }
  }
}

j'ai:
Erreur de segmentation : Core dumped.

Y a-t-il une erreur de syntaxe dans le programme?
Je précise que le type utilisé est:

Code:

1
2
typedef struct element {int valeur;struct element *lien} Element;
typedef Element *Liste;

et que le programme ci-dessus vise à enlister un entier dans une liste triée d'entiers sans doublons .

Merci!

02/02/2013, 23h53
Ngork
Je ne vois pas d'erreur a priori dans ton code (mais il n'y a pas grand chose pour en juger) sinon le point-virgule après le second élément (lien) dans la déclaration de ta structure Element, ce qu'il faudrait corriger :
Code:

1 2 3 4 5 6 typedef struct element { int valeur; struct element *lien; } Element;
02/02/2013, 23h56
imperio
Tu attribues a un pointeur l'adresse d'une variable qui sera detruite a la fin de la fonction donc lorsque tu voudras appeler le pointeur, il ne contiendra aucune donnee (ou tout du moins pas celle que tu veux, la magie des pointeurs qui pointent pas sur ce qu'il faut !).
Code:

1 2 3 4 Element newelement; newelement.valeur=v; newelement.lien=ptrcourant; ptrprecedent->lien = &newelement; /* pas bien !*/
03/02/2013, 01h02
Ngork

Oui, imperio a raison, un petit malloc serait des plus judicieux pour ton newelement !
Et je l'avais même pas vu ... 8O
Temps qu'j'aille me coucher moi !

Rebonjour,

j'ai pas très bien compris pourquoi &newelement n'était plus disponible...
mais j'ai modifié le programme avec du malloc en créant Liste ptrnewelement:

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
Liste enlister (Liste liste, int v){
  if (estListeVide (liste)){
      liste->valeur=v;
      liste->lien=NULL;
      return liste;
    }
  else {
    if (estElementListe (liste,v)){
      printf ("L'entier %d est deja present\n", v);
      return liste;
    }
    else {
      Liste ptrcourant=liste;
      Liste ptrprecedent;
      while (ptrcourant !=NULL && (v>(ptrcourant->valeur))){
        ptrprecedent=ptrprecedent;
        ptrcourant=(ptrcourant->lien);
      }
      Liste ptrnewelement;
      ptrnewelement = malloc (sizeof (Element));
      ptrnewelement->valeur=v;
      ptrnewelement->lien=ptrcourant;
      ptrprecedent->lien=ptrnewelement;
      return liste;
    }
  }
}

Malheureusement j'ai toujours le même message d'erreur:
Core dumped erreur de segmentation...

03/02/2013, 13h55
diogene
Citation:

j'ai pas très bien compris pourquoi &newelement n'était plus disponible...

Ce n'est pas qu'elle n'est plus disponible, c'est qu'elle ne correspond plus à rien : newelement est détruit en sortie de la fonction (en tant que variable locale) et son adresse (ou plutôt l'adresse qu'elle avait) n'a plus de sens.
Regle : on ne doit jamais retourner de quelque manière que ce soit l'adresse d'une variable locale.
Code:

1 2 3 Liste ptrprecedent; while (ptrcourant !=NULL && (v>(ptrcourant->valeur))){ ptrprecedent=ptrprecedent;
la dernière ligne citée est absurde

J'ai corrigé le code, mais j'ai toujours la même erreur ...

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
Liste enlister (Liste liste, int v){
  if (estListeVide (liste)){
      liste->valeur=v;
      liste->lien=NULL;
      return liste;
    }
  else {
    if (estElementListe (liste,v)){
      printf ("L'entier %d est deja present\n", v);
      return liste;
    }
    else {
      Liste ptrcourant=liste;
      Liste ptrprecedent;
      while (ptrcourant !=NULL && (v>(ptrcourant->valeur))){
        ptrprecedent=ptrcourant;
        ptrcourant=(ptrcourant->lien);
      }
      Liste ptrnewelement;
      ptrnewelement = malloc (sizeof (Element));
      ptrnewelement->valeur=v;
      ptrnewelement->lien=ptrcourant;
      ptrprecedent->lien=ptrnewelement;
      return liste;
    }
  }
}

SOS :(

03/02/2013, 15h55
diogene

Quelques pistes :

- Le code que tu présentes fait penser quand la liste est vide, elle possède quand même un élément. Il serait bon que tu donnes des explications sur comment est initialisée la liste et le code de estListeVide()

- Si tu veux insérer en tête de liste, alors tu ne rentres pas dans la boucle while() et ptrprecedent est non initialisé lorqu'on arrive à ptrprecedent->lien=ptrnewelement; -> plantage

- Si tu insère en tête de liste, la tête de liste doit changer or on ne voit pas de liste = ... dans ton code

Voici le type de la fonction estListeVide:

Booleen estListeVide (Liste liste)

J'ai corrigé le début de la fonction pour le cas où la liste est vide en créant ptrNewElement et la fin avec ptrprecedent:

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
Liste enlister (Liste liste, int v){
  printf("Ceci est ma fonction: \n");
  if (estListeVide (liste)){
    Liste ptrNewelement;
    ptrNewelement = malloc (sizeof (Element));
    ptrNewelement->valeur=v;
    ptrNewelement->lien = NULL;
    liste = ptrNewelement;
    return liste;
    }
  else {
    if (estElementListe (liste,v)){
      printf ("L'entier %d est deja present\n", v);
      return liste;
    }
    else {
      Liste ptrcourant=liste;
      Liste ptrprecedent = NULL;
      while (ptrcourant !=NULL && (v>(ptrcourant->valeur))){
        ptrprecedent=ptrcourant;
        ptrcourant=(ptrcourant->lien);
      }
      Liste ptrnewelement;
      ptrnewelement = malloc (sizeof (Element));
      ptrnewelement->valeur=v;
      ptrnewelement->lien=ptrcourant;
      if (ptrcourant == liste){
        liste=ptrnewelement;
        return liste;
      }
      else {
      ptrprecedent->lien=ptrnewelement;
      return liste;}
    }
  }
}

et ça marche.
Une dernière question:
est-ce qu'il faut finir la fonction avec des:
free (ptrprecedent), free (ptrnewelement) ... ?

Merci.

03/02/2013, 23h07
diogene

Citation:

Une dernière question:
est-ce qu'il faut finir la fonction avec des:
free (ptrprecedent), free (ptrnewelement) ... ?

Non :
ptrnewelement et ptrprecedent ont reçu l'adresse de zones allouées pour stocker les données (nouvelle zone pour le premier et déjà allouée pour le second). Si on fait un free() dessus, on va détruire les données. C'est pour pouvoir les conserver en sortant de la fonction que l'allocation dynamique a été utilisée. On n'utilisera un free() sur ces adresses que lorsqu'on voudra détruire ces maillons.
05/02/2013, 19h02
Glork

D'accord.
Merci à tous!