bonjour
J'ai un petit probleme avec un code C++ g=E9rant une liste d'objet:
j'ai :
class CParent
{
public:
CParent();
~CParent();
=2E...
}
class CObj1 : public CParent
{
public:
CObj1();
~CObj1();
=2E..
}
class CObj2 : public CParent
{
public:
CObj2();
~CObj2();
=2E..
}
class CObj3 : public CParent
{
public:
CObj3();
~CObj3();
=2E..
}
j'aimerais faire une liste qui regroupe CObj1, CObj2 et CObj3.
J'ai donc:
vector<parent*> m_objects;
pour ajouter je fais:
CObj *obj1 =3D new CObj1;
m_objects.push_back(obj);
=2E..
CObj *obj3 =3D new CObj3;
m_objects.push_back(obj);
la classe parent sert d'interface, elle comprends toutes les m=E9thodes=20
(abstraites) pour dialoguer avec les fils (obj).
Mon probleme est =E0 la destruction de cette liste.
Comme ce sont des pointeurs, il faut que j'appelle moi m=EAme le destruct=
eur:
for(vector<CParent*>::const_iterator itor =3D m_objects.begin();
itor !=3D m_objects.end();
++itor)
{
delete (*itor);
}
Mon probleme est donc le suivant: avec cette m=E9thode seul le destructeu=
r=20
de CParent est appel=E9, et pas celui de CObj1 si l'=E9l=E9ment est un CO=
bj1*,...
je suppose qu'en faisant une bidouille du genre
delelte (CObj1*) (*itor);
en fonction du type de l'objet, =E7a fonctionnerais.
Je pourrais stocker le type sous fourme d'un entier accessible via une=20
m=E9thode abstraite de la classe parente, mais je trouve =E7a un peu...=20
horrible.
Est-ce que vous pouvez me dire o=F9 j'ai p=EAcher, et surtout s'il y a un=
=20
autre moyen pour avoir une liste d'object de type diff=E9rent, mais=20
partageant la m=EAme interface.
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Patrick Mézard
"Gaetan" a écrit dans le message de news:bivv3g$vgv$
J'ai un petit probleme avec un code C++ gérant une liste d'objet:
j'ai :
class CParent { public: CParent(); ~CParent(); .... }
[snip]
Est-ce que vous pouvez me dire où j'ai pêcher, et surtout s'il y a un autre moyen pour avoir une liste d'object de type différent, mais partageant la même interface.
Tes destructeurs doivent être virtuels.
class CParent { public: CParent(); virtual ~CParent(); .... }
class CObj1 : public CParent { public: CObj1(); virtual ~CObj1(); //encore que là le virtual est optionel, le destructeur est sans doute virtuel par défaut si celui de la classe père l'est. ... }
Après ça, delete sur un pointeur de type CParent* appellera le bon destructeur suivant l'objet réellement pointé.
Patrick Mézard
"Gaetan" <gaetan.semet@free.fr> a écrit dans le message de
news:bivv3g$vgv$1@news-reader5.wanadoo.fr...
J'ai un petit probleme avec un code C++ gérant une liste d'objet:
j'ai :
class CParent
{
public:
CParent();
~CParent();
....
}
[snip]
Est-ce que vous pouvez me dire où j'ai pêcher, et surtout s'il y a un
autre moyen pour avoir une liste d'object de type différent, mais
partageant la même interface.
Tes destructeurs doivent être virtuels.
class CParent
{
public:
CParent();
virtual ~CParent();
....
}
class CObj1 : public CParent
{
public:
CObj1();
virtual ~CObj1(); //encore que là le virtual est optionel, le destructeur
est sans doute virtuel par défaut si celui de la classe père l'est.
...
}
Après ça, delete sur un pointeur de type CParent* appellera le bon
destructeur suivant l'objet réellement pointé.
"Gaetan" a écrit dans le message de news:bivv3g$vgv$
J'ai un petit probleme avec un code C++ gérant une liste d'objet:
j'ai :
class CParent { public: CParent(); ~CParent(); .... }
[snip]
Est-ce que vous pouvez me dire où j'ai pêcher, et surtout s'il y a un autre moyen pour avoir une liste d'object de type différent, mais partageant la même interface.
Tes destructeurs doivent être virtuels.
class CParent { public: CParent(); virtual ~CParent(); .... }
class CObj1 : public CParent { public: CObj1(); virtual ~CObj1(); //encore que là le virtual est optionel, le destructeur est sans doute virtuel par défaut si celui de la classe père l'est. ... }
Après ça, delete sur un pointeur de type CParent* appellera le bon destructeur suivant l'objet réellement pointé.
Patrick Mézard
Gaetan
Patrick Mézard wrote:
Est-ce que vous pouvez me dire où j'ai pêcher, et surtout s'il y a un autre moyen pour avoir une liste d'object de type différent, mais partageant la même interface.
Tes destructeurs doivent être virtuels.
class CParent { public: CParent(); virtual ~CParent(); ..... }
class CObj1 : public CParent { public: CObj1(); virtual ~CObj1(); //encore que là le virtual est optionel, le dest ructeur est sans doute virtuel par défaut si celui de la classe père l'est. .... }
Après ça, delete sur un pointeur de type CParent* appellera le bon destructeur suivant l'objet réellement pointé.
Patrick Mézard
En effet, j'avais oublier que les destructeurs peuvent être virtual (mais pas les constructeurs) Merci beaucoup!!
--
~~ Gaetan ~~ http://www.xeberon.net
Patrick Mézard wrote:
Est-ce que vous pouvez me dire où j'ai pêcher, et surtout s'il y a un
autre moyen pour avoir une liste d'object de type différent, mais
partageant la même interface.
Tes destructeurs doivent être virtuels.
class CParent
{
public:
CParent();
virtual ~CParent();
.....
}
class CObj1 : public CParent
{
public:
CObj1();
virtual ~CObj1(); //encore que là le virtual est optionel, le dest ructeur
est sans doute virtuel par défaut si celui de la classe père l'est.
....
}
Après ça, delete sur un pointeur de type CParent* appellera le bon
destructeur suivant l'objet réellement pointé.
Patrick Mézard
En effet, j'avais oublier que les destructeurs peuvent être virtual
(mais pas les constructeurs)
Merci beaucoup!!
Est-ce que vous pouvez me dire où j'ai pêcher, et surtout s'il y a un autre moyen pour avoir une liste d'object de type différent, mais partageant la même interface.
Tes destructeurs doivent être virtuels.
class CParent { public: CParent(); virtual ~CParent(); ..... }
class CObj1 : public CParent { public: CObj1(); virtual ~CObj1(); //encore que là le virtual est optionel, le dest ructeur est sans doute virtuel par défaut si celui de la classe père l'est. .... }
Après ça, delete sur un pointeur de type CParent* appellera le bon destructeur suivant l'objet réellement pointé.
Patrick Mézard
En effet, j'avais oublier que les destructeurs peuvent être virtual (mais pas les constructeurs) Merci beaucoup!!
--
~~ Gaetan ~~ http://www.xeberon.net
Michaël Cortex
Patrick Mézard wrote:
class CParent { public: CParent(); ~CParent(); .... }
[snip]
Est-ce que vous pouvez me dire où j'ai pêcher, et surtout s'il y a un autre moyen pour avoir une liste d'object de type différent, mais partageant la même interface.
Tes destructeurs doivent être virtuels.
class CParent { public: CParent(); virtual ~CParent(); .... }
class CObj1 : public CParent { public: CObj1(); virtual ~CObj1(); //encore que là le virtual est optionel, le destructeur est sans doute virtuel par défaut si celui de la classe père l'est. ... }
Après ça, delete sur un pointeur de type CParent* appellera le bon destructeur suivant l'objet réellement pointé.
Je dirais "les" constructeurs... Le destructeur de la classe CParent est aussi appelé dans ce cas-là (c'est bien ça ?). -- <=- Michaël "Cortex" Monerau -=>
Patrick Mézard wrote:
class CParent
{
public:
CParent();
~CParent();
....
}
[snip]
Est-ce que vous pouvez me dire où j'ai pêcher, et surtout s'il y a un
autre moyen pour avoir une liste d'object de type différent, mais
partageant la même interface.
Tes destructeurs doivent être virtuels.
class CParent
{
public:
CParent();
virtual ~CParent();
....
}
class CObj1 : public CParent
{
public:
CObj1();
virtual ~CObj1(); //encore que là le virtual est optionel, le
destructeur est sans doute virtuel par défaut si celui de la classe
père l'est. ...
}
Après ça, delete sur un pointeur de type CParent* appellera le bon
destructeur suivant l'objet réellement pointé.
Je dirais "les" constructeurs... Le destructeur de la classe CParent est
aussi appelé dans ce cas-là (c'est bien ça ?).
--
<=- Michaël "Cortex" Monerau -=>
class CParent { public: CParent(); ~CParent(); .... }
[snip]
Est-ce que vous pouvez me dire où j'ai pêcher, et surtout s'il y a un autre moyen pour avoir une liste d'object de type différent, mais partageant la même interface.
Tes destructeurs doivent être virtuels.
class CParent { public: CParent(); virtual ~CParent(); .... }
class CObj1 : public CParent { public: CObj1(); virtual ~CObj1(); //encore que là le virtual est optionel, le destructeur est sans doute virtuel par défaut si celui de la classe père l'est. ... }
Après ça, delete sur un pointeur de type CParent* appellera le bon destructeur suivant l'objet réellement pointé.
Je dirais "les" constructeurs... Le destructeur de la classe CParent est aussi appelé dans ce cas-là (c'est bien ça ?). -- <=- Michaël "Cortex" Monerau -=>
