[compilo Visual 2005] Fonctionnement du delete

Bonjour à tous,

J'ai une question sur le fonctionnement de l'opérateur delete en debug avec le compilo de Visual 2005.
Pour vous donner le contexte, nous devons réaliser un container de type anneau.
Nous avons tout d'abord une structure de type liste chainée :

Code:

---

1 2 3 4 5

struct tNode { T* elt; tNode* next_elt; }

---

Nous avons ensuite une classe dans laquelle nous allouons au constructeur un tableau de tNode:

Code:

---

tNode* nodes = new tNode[size_max+1];

---

Et enfin dans le destructeur de la classe, nous devons désallouer bien sur. Mais nous ne pouvons utiliser l'opérateur delete[] car certains éléments pourraient encore être utilisés ailleurs.
Nous faisons donc une boucle sur les éléments à libérer, mais voilà le delete semble libérer tout le tableau.

Concrètement, voici ce que nous avons en mémoire après allocation:

Citation:

---

0x003663CC fd fd fd fd ýýýý
0x003663D0 00 00 00 00 ....
0x003663D4 d8 63 36 00 Øc6.
0x003663D8 00 00 00 00 ....
0x003663DC e0 63 36 00 àc6.
0x003663E0 00 00 00 00 ....
0x003663E4 e8 63 36 00 èc6.
0x003663E8 00 00 00 00 ....
0x003663EC d0 63 36 00 Ðc6.
0x003663F0 fd fd fd fd ýýýý

---

Le tableau commence à 0x003663D0 et se finit à 0x003663EC, pas de problème.
Nous déclarons un pointeur sur le 1er élement du tableau, puis nous faisons un delete sur ce pointeur:

Code:

---

1 2	tNode* elt = nodes[0]; delete elt;

---

où front est un attribut de la classe qui pointe vers le 1er élément du tableau.
Et voila ce que nous avons en mémoire après ces instructions :

Citation:

---

0x003663CC ee fe ee fe îþîþ
0x003663D0 ee fe ee fe îþîþ
0x003663D4 ee fe ee fe îþîþ
0x003663D8 ee fe ee fe îþîþ
0x003663DC ee fe ee fe îþîþ
0x003663E0 ee fe ee fe îþîþ
0x003663E4 ee fe ee fe îþîþ
0x003663E8 ee fe ee fe îþîþ
0x003663EC ee fe ee fe îþîþ
0x003663F0 ee fe ee fe îþîþ

---

Apparemment le tableau a été libéré dans son intégralité !! Comme si nous avions fait un delete[], ce que nous voulions justement éviter.
J'aimerais donc savoir si c'est bien le compilo Visual qui ne respecte pas la norme, et qui désalloue jusqu'à rencontrer fd fd fd fd, alors qu'il ne devrait désallouer que l'élément pointé par elt ?

Merci par avance pour votre aide.

Bonjour,

C'est un comportement normal. Le problème vient du fait que tu alloues une tableau de tNode:

Code:

---

1 2	tNode* nodes = new tNode[size_max+1];

---

Alors que c'est plus probablement un tableau de pointeur de tNode que tu souhaitais (comme ça tu peux libérer n'importe quel objet du tableau sans libérer le tableau entier). Du coup, à la libération, c'est tout le tableau qui disparait.

Code minimal du problème:

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

typedef struct _TNODE{   int elem; struct _TNODE* next;   }TNODE, *PTNODE;   #define MAX_SIZE 10 int main(int argc, char* argv[]) { PTNODE nodes = new TNODE[MAX_SIZE];   for(int i = 0; i < MAX_SIZE; i++) { nodes[i].elem = i; if(i < MAX_SIZE - 1) nodes[i].next = &nodes[i+1]; else nodes[i].next = &nodes[0]; }   delete nodes; //libère tout le tableau!   return 0; }

---

Ce que tu souhaites faire, c'est probablement quelque chose comme ça (code minimal avec un tableau, à débugger):

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 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

typedef struct _TNODE{   int elem; struct _TNODE* next;   }TNODE, *PTNODE;   #define MAX_SIZE 10 int main(int argc, char* argv[]) { //tableau de pointeur vers TNODE* PTNODE* nodes = new PTNODE[MAX_SIZE];   //init elem for(int i = 0; i < MAX_SIZE; i++) { PTNODE pnode = new TNODE; pnode->elem = i;   nodes[i] = pnode; }   //init next for(int i = 0; i < MAX_SIZE; i++) { if( i < (MAX_SIZE - 1)) nodes[i]->next = nodes[i+1]; else nodes[i]->next = nodes[0]; }   //efface 'node' à index 1 delete nodes[1]; #ifndef _DEBUG nodes[1] = NULL; #endif   //node[0]->next pointe maintenant vers node[2] nodes[0]->next = nodes[2];   //affichage PTNODE current_node = nodes[0]; do { printf("[%p] elem: %d ; next: %p\n", current_node, current_node->elem, current_node->next); current_node = current_node->next; }while(current_node != nodes[0]);   //test sur élément libéré. #ifdef _DEBUG printf("[%p] elem: %d ; next: %p\n", nodes[1], nodes[1]->elem, nodes[1]->next); #endif   //libération des pointeurs current_node = nodes[0]; do { PTNODE next = current_node->next; delete current_node; current_node = next; }while(current_node != nodes[0]);   //libère tableau delete[] nodes;   return 0; }

---

Ceci dit, pour une liste circulaire, tu peux très bien te passer du tableau (je dirais même que c'est plutôt recommandé).

Chaque élément pointe vers le suivant ('next'). La disparition (libération) d'un noeud doit alors obligatoirement s'accompagner d'une mise à jour du pointeur 'next' de l'élément qui pointait sur celui libéré: comme ça, plus besoin de tableau !

Merci beaucoup pour ta réponse. J'avais complétement oublié de revenir après l'avoir lu et fait qq tests, désolé.

En fait j'avais bien besoin d'un tableau de tNode et non de tNode*, ceci dans un but de performance, et donc pour éviter de faire appel un trop grand nombre de fois à new().
Mais j'ai contourné le problème d'une autre manière.

Ceci dit, il y a quand même qqch qui m'échappe, tu dis "C'est un comportement normal".

Hors il me semblait que quand on allouait un tableau d'objets quelconques, avec Obj* tab = new Obj[n], alors il fallait le libérer avec delete[], qu'un simple delete ne libérait que le 1er élément, ou que le comportement était indéfini (j'ai lu les 2 possibilités sur le net).
Hors ici, il semble que le delete sans les [] libère bien tout le tableau, voila pourquoi je pensais que le compilo de visual prenait des libertés avec la norme.
Cela reste assez mystérieux pour moi. :)

Encore merci.