Discussion :

[delire8]

Bonjour,

Apparamment, il y a une petite subtilité avec les pointeurs que je n'ai pas compris, et que j'aimerais bien comprendre. Je dispose d'une liste codée comme suit :

Code :

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

1
2
3
4
5
struct Lst
{
  Node* m_Content;
  struct Lst * m_Next;
} Liste;

J'ai donc un pointeur sur le premier élément (m_First) , que je conserve. Mais j'ai aussi un autre pointeur pointant a peu près n'importe dans la liste : m_Cur;

Réguliérement, je veux libérer le contenu (ie : libérer m_Content) pour un élément sans casser la chaine : m_Content est alors mis à NULL, mais m_Next reste intact, et l'élément précédent continu de pointer ce "noeud vide".
Si je copie m_First, parcours la liste jusqu'à mon élément, et libére, ca marche.
Mais si je fais free(m_Cur->m_Content), deux cas : soit ca plante (alors que je me suis assuré avant que m_Content était non nul...) soit ca marche, mais ca n'a aucun effet sur ma liste ! Comme si m_Cur->m_Content n'était qu'une copie de ce que je veux supprimer, située ailleurs, que cette copie a été bien libérée, mais pas l'original ! Où est la subtilité ?


Et d'une manière générale, quelles sont les causes possibles d'un plantage (genre seg fault) lors d'une instruction free(ptr), PRECEDEE d'un if( !ptr ) (et suivi d'un ptr = NULL ) ?

Merci

Cordialement

[Emmanuel Delahaye]

Apparamment, il y a une petite subtilité avec les pointeurs que je n'ai pas compris, et que j'aimerais bien comprendre. Je dispose d'une liste codée comme suit :

Montre ton code.

[diogene]

Mais si je fais free(m_Cur->m_Content), deux cas : soit ca plante (alors que je me suis assuré avant que m_Content était non nul...) soit ca marche, mais ca n'a aucun effet sur ma liste

free(NULL) est possible et ne plante pas (mais évidemment ne fait rien) .
La question n'est pas de savoir si m_Content est NULL, mais si
- m_Cur est NULL
- m_Cur n'est pas NULL mais pointe ailleurs que sur un élément de la liste ou sur un élément de la liste déjà détruit
- m_Cur n'est pas NULL et pointe sur un élément de la liste et m_Content n'est pas NULL mais n'a pas été initialisé ou pointe sur un objet déjà détruit.

Pour en savoir plus, il faudrait voir le code incriminé.

[Sve@r]

Et d'une manière générale, quelles sont les causes possibles d'un plantage (genre seg fault) lors d'une instruction free(ptr), PRECEDEE d'un if( !ptr ) (et suivi d'un ptr = NULL ) ?

Le free(ptr) plantera si
- ptr contient une adresse invalide autre que NULL
- ptr a déjà été freeé (super barbarisme) auparavant

Le "if(! ptr)" est généralement inutile car tu te dois, à chaque moment de ton code, savoir quels sont les pointeurs valides et donc n'appeler "free()" que quand il faut. Bon, il y a les exceptions (style une fonction de libération générale qui est appelée dans tous les cas alors que tout n'est pas forcément alloué) où ça se justifie mais ça reste généralement exceptionnel.

Le "ptr = NULL" est à mon avis pareillement inutile pour les mêmes raisons (si je l'alloue plus tard, alors le NULL est inutile et si je l'alloue pas, alors c'est que je m'en sers pas donc le NULL reste inutile) mais d'une part cet avis n'engage que moi et d'autre part là aussi il peut y avoir des exceptions comme ci-dessus.

[Médinoc]

La remise à NULL n'est inutile que si le programme n'a aucun bug, ce qui évidemment n'est pas garanti.

Donc, on remet à NULL, ce qui permet généralement:

• De contourner les problèmes de double-free
• De détecter plus facilement un accès au pointeur après destruction.

[souviron34]

free(NULL) est possible et ne plante pas (mais évidemment ne fait rien) .
.

Peut-etre que cela a ete modifie, mais sur certains systemes (HPUX et SunOS en particulier, en tous cas il y a une dizaine d'annees) free(NULL) entrainait un crash (coredump).

[Médinoc]

On peut espérer que ça ait été corrigé depuis, car la norme exige que free(NULL) ne plante pas.

Par contre, fclose(NULL) est un comportement indéfini.

[siegfried64]

soit ca marche, mais ca n'a aucun effet sur ma liste ! Comme si m_Cur->m_Content n'était qu'une copie de ce que je veux supprimer, située ailleurs, que cette copie a été bien libérée, mais pas l'original ! Où est la subtilité ?

quand on appelle la fonction free(m_Cur->m_Content), effectivement elle libere la zone mémoire pointé et la rend à l'os, mais m_Cur->m_Content pointe toujours sur cette adresse mémoire, lors de ton parcours de liste tu essaie d'y acceder, donc soit tu y retrouve tes données intactes parceque cette zone mémoire n'a pas été utilisé par autre programme d'où l'absence de tout effet sur ta liste, soit elle est utilisé donc ton application plante. Enfin c'est ce que je pense, aprés la liberation tu devrais peut etre faire :

Code :

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

m_Cur->m_Content=NULL;