Explication Destructeur D'objet

Version imprimable

:DBonjour je debut dans le c++, pour illustrer l'utilisation de l'heritage, des notion de constructeur, destructeur,contructeur de recopi j'ai fait quelle que classe representant une classe de base virtuel piece. Sur la quelle le classe cavalier heriete. Par la suite je fait un ptit test dans le main.cpp pour pouvoir suivre la contruction destruction copie de mes objets.

Lorsque j'execute le programme la destruction de l'objet cavalier ne s'effectu pas. Quelqu'un pourait t'il m'explique d'ou vien le probleme?:cry:

Module piece.h

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
#ifndef PIECE_H
#define PIECE_H
 
#include <iostream>
using namespace std;
class piece
{
private:
		short X;
		short Y;
		short joueur;//noir=1 et  blanc=0
 
protected:
        void setX(short x);
		void setY(short y);	
		void setjoueur(int joueur);
		char * nom;
 
public:
		piece(short x, short y, char * nom, short joueur);
		piece(piece & a);
		~piece();
		short getX()const;
		short getY()const;		
		short getjoueur() const;
		char * getnom()const;
		virtual void affiche() const =0;//methode virtuel à redefinir
		virtual short mouv(short x, short y) =0;//methode virtuel à redefinir
 
};
 
#endif

piece.cpp

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
#include "piece.h"
piece::piece (short x,short y, char * n, short j)
{   cout<<this<<" constructeur piece"<<" nom"<<&nom<<"\n";
	X=x;
	Y=y;
	nom = new char[8];
	strcpy(nom, n);
	joueur=j;
}
piece::~piece()
{cout<<this<<" detructeur piece"<<" nom"<<&nom<<"\n";
	delete nom;
}
piece::piece(piece & a)
{	cout<<this<<" copie piece ";
	X=a.X;
	Y=a.Y;
	nom = new char[8];
	strcpy(nom, a.nom);
	joueur=a.joueur;
	cout<<"nom"<<&nom<<"\n";
}
 
short piece::getX ()const
{
	return X;
}
short piece::getY ()const
{
	return Y;
}
void piece::setX (short x)
{
	X=x;
}
void piece::setY (short y)
{
	Y=y;
}
 
 
short piece::getjoueur ()const
{
	return joueur;
}
 
 
char * piece::getnom()const
{
	return nom;
}

cavalier.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#ifndef _CAVALIER_H
#define _CAVALIER_H
#include "piece.h"
 
class cavalier: public piece
{
 
	public:
        cavalier(short x, short y, char * nom, short joueur);
		~cavalier();
		cavalier(cavalier & a);
		short mouv(short x, short y);//redefinition de class virtuel heriter 
		void affiche()const;//affiche juste le nom du pion //redefinition de class virtuel heriter 
};
#endif

cavalier.cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include "cavalier.h"
 
cavalier::cavalier (short x, short y, char * n, short j):piece( x,  y, n, j)
{
cout<<this<<" constructeur cavalier"<<" nom"<<&nom<<"\n";
}
cavalier::~cavalier()
{cout<<this<<" destructeur cavalier"<<" nom"<<&nom<<"\n";
	delete nom;
}
cavalier::cavalier(cavalier & a):piece(a)
{	
	cout<<this<<" copie cavalier"<<" nom"<<&nom<<"\n";
}
short cavalier::mouv (short x, short y)
{
	return 0;
}
void cavalier::affiche()const
{
	cout<<nom;
}

main.cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include "echiquier.h"
#include<iostream>
using namespace std;
 
void f(cavalier f)
{
	cout<<"  dans f()\n";
}
 
int main()
{
 cavalier a(1,2,"toto",1);
 f(a);
 return 0;
}

10/01/2008, 02h18
JolyLoic

J'ai pas lu dans les détails, mais quelques points en vrac :
- En général, on préfère comme constructeur de copie la version prenant en paramètre une référence constante : piece(piece const & a); Il marche dans plus de cas.
- Il te manque l'opérateur=, généralement nécessaire quand on défini destructeur et constructeur de copie.
- Dans le destructeur de la classe dérivée, faire un delete nom; est une erreur : Le pointeur sera déjà été désalloué par le destructeur de la classe de base appelé implicitement.
- Dans ce genre de hiérarchie de classe, il est souvent nécessaire que le destructeur soit virtuel.
- Aucun de ces points n'implique un non appel du destructeur. Que te sort exactement ton programme ?
10/01/2008, 10h00
Médinoc

Lorsque tu fais delete sur un piece*, le destructeur de piece doit être déclaré virtual si tu veux que le destructeur de cavalier soit appelé.

Salut,

Plusieurs choses, en vrac:

Le code tel que donné ne compile pas... tu as oublié de fournir le fichier "echiquiers.h" (et son implémentation)...
Par contre, on peut palier son absence en remplacant #include "echiquier.h" par #include "cavalier.h" ;) (pense toujours à vérifier que le code minimum que tu fournis arrive à reproduire effectivement le comportement que tu veux mettre en évidence :D)

L'utilisation de la directive using namespace n'est, clairement, pas recommandée dans les fichiers d'en-tete, pour la simple et bonne raison que la directive va se répercuter selon le jeu des instruction à une bonne partie de ton code, et que tu perd dés lors tout l'avantage des espace de nommage ;)

Préfère la classe string, disponible par inclusion du fichier d'en-tete <string> dans l'espace de nommage std à l'utilisation de chaines de caractères "C style" (tableaux de caractères terminés par un '\0'), ta vie n'en sera que simplifiée, et, entre autres, tu éviteras tous les risques liés aux fait que tu peux à tout moment, avec une chaine "C style", essayer de faire rentrer 10 caractères là ou tu n'a prévu la place que pour ... 9 ;):P

Enfin, le code que tu fournis ne représente absolument pas le comportement que tu cherche à mettre en évidence, car le résultat est excactement celui auquel on peut s'attendre...
Code:

1 2 3 4 5 6 7 8 9 constructeur de piece constructeur de cavalier copie de piece copie de cavalier dans f() destructeur de cavalier (la copie) destructeur de piece (la copie) destructeur de cavalier (l'original) destructeur de piece (l'original)
(j'ai juste remplacé les adresses affichées par les parenthèses quand la précision est utile ;))

Ce qui est normal parce que tu ne fais absolument pas appel au polymorphisme ;)

Pour représenter le comportement que tu veux, le code serait, dans main.cpp
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 #include "cavalier.h" #include<iostream> using namespace std; void f(piece* f) { cout<<" dans f()\n"; } int main() { piece* a = new cavalier(1,2,"toto",1); f(a); delete a; return 0; }
ou par
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 #include "cavalier.h" #include<iostream> using namespace std; void f(cavalier* f) { cout<<" dans f()\n"; } int main() { piece *a = new cavalier(1,2,"toto",1); f((cavalier*) a); /* très mauvaise conversion ;), mais conversion quand meme */ delete a; return 0; }
de manière à essayer de mettre le comportement polymorphique en évidence

A ce moment là, on obtient bien:
Code:

1 2 3 4 constructeur de piece constructeur de cavalier dans f() /* remarque l'absence de copie :D*/ destructeur de piece
et la raison en a été donnée par médinoc: pour que la destruction dynamique d'un objet référencé comme étant la classe mère se fasse correctement, il faut que les destructeurs soient déclarés virtuels (au moins celui de la classe mere, mais, pour un soucis de lisibilité principalement, l'idéal est de rendre également les destructeurs des classes filles virtuels ;)) ;)

Ainsi, le simple fait de remplacer, dans piece.h, la ligne

Code:

~piece();

par

Code:

virtual ~piece();

suffira à le faire à nouveau réagir correctement sous la forme de
Code:

1 2 3 4 5 constructeur de piece constructeur de cavalier dans f() /* remarque l'absence de copie :D*/ destructeur de cavalier destructeur de piece
(cependant, comme indiqué, il est préférable, dans un simple soucis de visibilité, de rendre le destructeur de cavalier virtuel ;))

13/01/2008, 18h27
mkacho

merci pour les conseilles

merci beaucoup pour vos explications j'ai mieu comprit le fonctionement du cpp.:mrgreen::king: