voila j'ai quelques petits souci avec le free  
 
j'ai a un segment defaut à un free lorsque je veux librer le bloc.  
 
Dans mon cas je pense que cela est du que je ne fournis pas la bonne adresse, pas la meme que le malloc m'avait retourné.  
je suis persudé que je n'ai pas appellé 2 fois free sur le meme bloc d'ailleur
 
 
Ma question puis je vois les adresse que stocke des char *, j'ai essayé de faire avec un printf et un code format %d mais je suis pas sur que cela soit ca je crois que la meme est sauvegardé en hexa ....
 
Pourquoi je veux connaitre le contenu de mes pointeurs ?
et bien c'est pour connaitre les adresses de mes pointeurs et savoir si les adresses entre les free et les malloc corresponde.

%d est bon dans ton cas (i386 je suppose). Dans le cas général %ld sera plus portable... Et si tu veux afficher l'addresse en hexa, utilise %lx ou %lX.

mais biensur ... c'est trop compliqué d'utiliser %p

un free sur un bloc déjà désaloué ne devrait pas poser de problème (même si ça dénote un malfonctionnement du ton algo)

tu plaisantes là?

me suis jamais amusé à le faire mais c'est ce que j'ai lu
 
pas de bonne toi ce matin

tu ferais bien de lire un peu plus, le bug/faille du double free, c'est archi connu

http://www.micro.uqam.ca/Ressource [...] /free.html

Un pointeur qui pointe vers une zone mémoire désallouée et un pointeur a null, c'est pas la meme chose...

oui. j'ai lu un peu vite en effet...

c'est ce que j'étais en train de me dire... mea culpa.
 
merci Taz

J'aimes bien quand Taz intervient    
Y'a toujours une certaine animation  

Généralement ton compilo te fourni les outils pour détecter ce genre de cas. Tu utilises quoi ?

j'utilise gcc
 
bon mon probleme est resolu, je specifié bien la bonne adresse mais j'ai fais un debordement. Je m'explique j'ai fais une premeire allocation, j'ai utilisé la variable puis apres j'ai realloué (avec un free puis malloc), j'ai utilisé le bloc memoire.
 
Puis apres j'ai fais une 3ème reallocation. J'ai utilisé le bloc normallement. Puis apres dans mon programme j'ai voulu reutilisé ce bloc memoiire et j'ai fais un debordement. Cela n'a pas généré d'erreur car, le 3 malloc m'a fournis la meme première adresse que le premiere malloc m'avait fourni.  
 
1 er malloc :
-------------------------------------------------------------------------------
0x804d208  |             |             |                |      *         |    *      |   *      |
-------------------------------------------------------------------------------
 
3ème malloc :
-------------------------------------------------
0x804d208  |             |             |                |
--------------------------------------------------
 
les blocs du 1er malloc avec les * n'ont pas été réalloué par le systeme du coup je n'ai eu d'ereur lors de mon debordement.  
 
 
Par contre chose que je n'arrive pas a comprendre, pour moi ce n'est pas le probleme de free que j'ai fais un Overflow. Pour moi il doit librer le bloc que le 3ème malloc m'a filé et point bar ....
 
Solution :
Donc pour reseoudre mon probleme, j'ai fais un 4ème malloc pour reserver plus de bloc et ainsi eviter l'Overflow

j'ai rien bité

Solution:
Corriger ton code buggé qui fait un overflow.

il veux dire qu'il a écrasé de la mémoire derrière un bloc alloué par malloc, et que ça fesait planter son free ultérieur (enfin je pense)

ce que je veux dire, j'ai plusieurs allocation/desalocation de buf  
1 er malloc (buf = malloc (7)) :  
-------------------------------------------------------------------------------------------------------------------  
0x804d208  | 0x804d209| 0x804d210 | 0x804d211 | 0x804d212 | 0x804d213 | 0x804d214 |  
-----------------------------------------------------------------------------------------------------------------
 
 
3 ème malloc  (buf = malloc (5)) :
-------------------------------------------------------------------------------------------------------------------  
0x804d208  | 0x804d209| 0x804d210 | 0x804d211 | 0x804d212 |                   |                   |  
-----------------------------------------------------------------------------------------------------------------
 
au 1er et le 3eme malloc, on m'a fourni la meme adresse : 0x804d208.  
lorsque j'ai utilisé, le bloc du 3ème bloc, j'ai fais un debordement. J'ai ecrit sur les blocs de 0x804d208 à 0x804d12, mais j'ai également écris à l'adresse 0x804d213. J'ai fais un debordement. Lorsque j'avais fais mon 3ème malloc, j'avais reservé que jusqu'a 0x804d212. Lorsque j'ai ecris sur 0x804d213, je n'ai eu d'erreur car je pense qu'entre le 1er malloc et le 3ème malloc, l'adresse 0x804d213, n'a pas été réutilisé par le systeme.  
 
Mais du fais que j'ai ecris sur 0x804d213, lorsque j'ai voului liberer le bloc  0x804d208 -> 0x804d212 que malloc m'a fourni, free n'a pas voulu car j'ai ecris également en dehors. Cela me surprends mais ca a l'air d'etre ca ...
 
J'espere que ce coup ci je me suis fais mieux comprendre ...

réalloué une 4ème fois et inclure l'adresse 0x804d21 dans mon exemple

C'est quoi la question ?
Tu nous dit que du fais des overflow, tu nous explique que ça plante. Soit, c'est normal. Et ?

non ca plante pas lorsque j'ecris car j'avais precedement alloué le meme bloc et ca n'a pas été réutilisé ...
 
Mais ce qui me surprends, c'est lorsque je libere avec un free. Pour moi peu importe que je fasse un Overflow lorsque je libere c'est pas son probleme ...
 
 
Apres peut etre que cela vient du fait que j'ai ecrasé un flag que le 3ème malloc a posé necessaire pour faire un free par la suite.
Et en faisant mon  Overflow j'ai écrasé le flag et du coup le free ne sait pas ou s'arretter, il ne sait pas jusqu'a quel bloc il doit liberer. Cela vient peut etre de la.

Faut peut-être "faire du ménage" dans la façon de traîter la mémoire, que ce soit plus "limpide" à gérer... :-)

j'ai toujours rien bité, je comprends rien à tes calculs et suposition foireuses qui conduisent directe à l'erreur de segmentation

Le manière dont la mémoire est gérée par la lib standard est spécifique à ton compilateur. Tes constatations ne sont pas généralisables. Sur un autre système / compilo / version de ton compilo, ça peut faire autre chose.