Discussion :

[Lawyer666]

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 :

S�lectionner tout - Visualiser dans une fen�tre � part

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 :

S�lectionner tout - Visualiser dans une fen�tre � part

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:

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 :

S�lectionner tout - Visualiser dans une fen�tre � part

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 :

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.

[Neitsa]

Bonjour,

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

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

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 :

S�lectionner tout - Visualiser dans une fen�tre � part

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 :

S�lectionner tout - Visualiser dans une fen�tre � part

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 !

[Lawyer666]

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.