Crash inexplicable lors de l'appel de "delete"

Bonjour tous le monde,

voila mon problème consiste en un crash non expliqué lors de l'appel de l'operateur delete[].

Voici le code:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

char* l_pChar = new char[i_sHexaValue.toStdString().size()];   strcpy(l_pChar,i_sHexaValue.toStdString().c_str());   unsigned char* l_pUnsignedChar = new unsigned char[i_sHexaValue.toStdString().size()]; l_pUnsignedChar = reinterpret_cast< unsigned char * >(l_pChar);   char const* l_pcFinalValue = new char const[i_sHexaValue.toStdString().size()]; l_pcFinalValue = reinterpret_cast< char const * >(l_pUnsignedChar); l_sResult = QString(l_pcFinalValue);   delete[] l_pChar; delete[] l_pUnsignedChar; delete[] l_pcFinalValue;

---

J'espère avoir une explication de ce comportement (peut être prévisible et attendu).
Je vous remercie d'avance.

Bonjour,

Il y a plusieurs problèmes.

1)

Code:

---

1 2 3

l_pUnsignedChar = reinterpret_cast< unsigned char * >(l_pChar); l_pcFinalValue = reinterpret_cast< char const * >(l_pUnsignedChar);

---

Une fois passé ce bout de code les trois pointeurs l_pChar, l_pUnsignedChar et l_pcFinalValue ont tous la même valeur donc pointent vers le même morceau de mémoire. Du coup ce bout de code :

Code:

---

1 2 3

delete[] l_pChar; delete[] l_pUnsignedChar; delete[] l_pcFinalValue;

---

appellent trois fois delete[] sur le même pointeur -> segfault

2)

Code:

---

1 2	char* l_pChar = new char[i_sHexaValue.size()]; strcpy(l_pChar,i_sHexaValue.c_str());

---

Dans la première ligne tu alloues un tableau de char de la taille de i_sHexaValue. Hors dans la deuxième ligne tu copie dans ce tableau une chaine de taille size + 1 (car il y a le '\0' en plus), donc il y a un dépassement de tableau.

Après la ligne 7, l_pUnsignedChar et l_pChar pointent au même endroit. De même ligne 10 avec l_pcFinalValue.

Donc les delete[] vont tenter de libérer trois fois la même chose.
Ce qui est interdit.

Au passage, tu ferais bien de revoir comment fonctionnent les pointeurs. ;)

[EDIT : Le temps de taper le message ... !]

Euh, je vois aussi beaucoup d'acrobaties dans un but que je ne cerne pas vraiement?
Ton but est visiblement de faire une série de reinterpret_cast sur des pointeurs...pourquoi l'allocation dynamique et la recopie dans ce cas?
Pour mémoire l'allocation dynamique à la main est à éviter comme la peste à moins d'y être vraiement obligé, justement à cause des risques d'erreur de gestion de la mémoire qui sont si vite arrivées.

Bon, je vais vous expliquer un peu mon "besoin". En faite, je récupère une valeur comme étant un string, je dois l'interpréter comme étant un unsigned char * et je dois par la suite l’écrire dans un fichier xml (donc la reconvertir en string..).
Si vous avez une meilleur proposition a donner, je suis prenant..
Et merci encore.

Si je comprends bien, c'est un besoin de VOIR le même tableau de char (aucune modification en vue je présume?) sous trois angles (unsigned char*, const char*).
Pour les visions const, qui ne seront jamais modifiées, aucune raison de faire de copie.
Que fais-tu à ton unsigned char*? Ecris-tu dedans?

Non je modifie pas le unsigned char

As tu la maîtrise sur le code qui l'utilise (en lecture, donc)? Si tu pouvais aller vers const unsigned char*, tu n'aurais aucune copie (donc aucun new, et aucun delete) à faire, juste à initialiser des pointeurs alias. L'intérêt du const étant d'interdire la modification, donc de garantir que tu n'auras pas d'effets de bord incompréhensibles.