Petit problème sur lequel je bute :
J'ai une classe qui contient un pointeur sur une classe B qui est une classe
abstraite:
class A
{
B* b
A(B* b) : b(b) {}
};
class C : public B {};
class D : public B {};
Si je fais une copie de A, c'est le pointeur qui va être copié et mes deux
objets pointeront sur le même objet dérivé de B.
Je veux que l'objet pointé par b soit aussi copier, je m'appretait donc à
déclarer un constructeur de copie et l'opérateur d'affectation...
Seulement, comment je fait pour construire mon nouvel objet, je ne connait
pas son type...
A::A(const A& a)
{
this->b = new ???
}
Y'a surement un truc évident qui m'echappe ou quelque chose que je fais mal,
mais je n'arrive pas à trouver quoi ?
Quel est la bonne méthode pour faire cela ?
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
Christophe de VIENNE
Outils1 wrote:
Bonjour à tous,
Bonjour,
[snip]
A::A(const A& a) { this->b = new ??? }
Y'a surement un truc évident qui m'echappe ou quelque chose que je fais mal, mais je n'arrive pas à trouver quoi ? Quel est la bonne méthode pour faire cela ?
Une méthode commune est de définir dans ta classe B une méthode virtuelle de duplication :
class B { // ... virtual B * Clone() const { return new B(*this); }; // ... };
Et de la surdéfinir dans ses classes dérivées :
class C: public B { // ...
virtual C * Clone() const { return new C(*this); };
// si tu utilise un compilateur un peu ancien, il te // faudra peut-être écrire : // virtual B * Clone() const {
/// ... };
Ainsi pour dupliquer ton champ de type B* tu n'as plus qu'à faire :
A::A(const A& a) : b(a.b->Clone()) { }
A+
Christophe
Outils1 wrote:
Bonjour à tous,
Bonjour,
[snip]
A::A(const A& a)
{
this->b = new ???
}
Y'a surement un truc évident qui m'echappe ou quelque chose que je fais mal,
mais je n'arrive pas à trouver quoi ?
Quel est la bonne méthode pour faire cela ?
Une méthode commune est de définir dans ta classe B une méthode
virtuelle de duplication :
class B {
// ...
virtual B * Clone() const {
return new B(*this);
};
// ...
};
Et de la surdéfinir dans ses classes dérivées :
class C: public B {
// ...
virtual C * Clone() const {
return new C(*this);
};
// si tu utilise un compilateur un peu ancien, il te
// faudra peut-être écrire :
// virtual B * Clone() const {
/// ...
};
Ainsi pour dupliquer ton champ de type B* tu n'as plus qu'à faire :
Y'a surement un truc évident qui m'echappe ou quelque chose que je fais mal, mais je n'arrive pas à trouver quoi ? Quel est la bonne méthode pour faire cela ?
Une méthode commune est de définir dans ta classe B une méthode virtuelle de duplication :
class B { // ... virtual B * Clone() const { return new B(*this); }; // ... };
Et de la surdéfinir dans ses classes dérivées :
class C: public B { // ...
virtual C * Clone() const { return new C(*this); };
// si tu utilise un compilateur un peu ancien, il te // faudra peut-être écrire : // virtual B * Clone() const {
/// ... };
Ainsi pour dupliquer ton champ de type B* tu n'as plus qu'à faire :
A::A(const A& a) : b(a.b->Clone()) { }
A+
Christophe
Benoit Rousseau
Outils1 wrote:
Bonjour à tous,
Petit problème sur lequel je bute : J'ai une classe qui contient un pointeur sur une classe B qui est une classe abstraite:
class A { B* b A(B* b) : b(b) {} };
class C : public B {}; class D : public B {};
Si je fais une copie de A, c'est le pointeur qui va être copié et mes deux objets pointeront sur le même objet dérivé de B. Je veux que l'objet pointé par b soit aussi copier, je m'appretait donc à déclarer un constructeur de copie et l'opérateur d'affectation...
Seulement, comment je fait pour construire mon nouvel objet, je ne connait pas son type...
tu peux créer une fonction abstraire dans B qui retourne une nouvelle copie de l'objet à copier :
class B { B* copy() = 0; };
class C : public B { B* copy() { return new C( *this ) ; } //appel constructeur C(const C&) };
class D : public B { B* copy() { return new D(...); } };
et dans A( const A& other ) : b = other.b->copy();
-- -------------------------------------------- Benoît Rousseau : roussebe at spray dot se Jouez en programmant : http://realtimebattle.sourceforge.net/
Outils1 wrote:
Bonjour à tous,
Petit problème sur lequel je bute :
J'ai une classe qui contient un pointeur sur une classe B qui est une classe
abstraite:
class A
{
B* b
A(B* b) : b(b) {}
};
class C : public B {};
class D : public B {};
Si je fais une copie de A, c'est le pointeur qui va être copié et mes deux
objets pointeront sur le même objet dérivé de B.
Je veux que l'objet pointé par b soit aussi copier, je m'appretait donc à
déclarer un constructeur de copie et l'opérateur d'affectation...
Seulement, comment je fait pour construire mon nouvel objet, je ne connait
pas son type...
tu peux créer une fonction abstraire dans B qui retourne une nouvelle
copie de l'objet à copier :
class B {
B* copy() = 0;
};
class C : public B {
B* copy() { return new C( *this ) ; } //appel constructeur C(const C&)
};
class D : public B {
B* copy() { return new D(...); }
};
et dans A( const A& other ) :
b = other.b->copy();
--
--------------------------------------------
Benoît Rousseau : roussebe at spray dot se
Jouez en programmant : http://realtimebattle.sourceforge.net/
Petit problème sur lequel je bute : J'ai une classe qui contient un pointeur sur une classe B qui est une classe abstraite:
class A { B* b A(B* b) : b(b) {} };
class C : public B {}; class D : public B {};
Si je fais une copie de A, c'est le pointeur qui va être copié et mes deux objets pointeront sur le même objet dérivé de B. Je veux que l'objet pointé par b soit aussi copier, je m'appretait donc à déclarer un constructeur de copie et l'opérateur d'affectation...
Seulement, comment je fait pour construire mon nouvel objet, je ne connait pas son type...
tu peux créer une fonction abstraire dans B qui retourne une nouvelle copie de l'objet à copier :
class B { B* copy() = 0; };
class C : public B { B* copy() { return new C( *this ) ; } //appel constructeur C(const C&) };
class D : public B { B* copy() { return new D(...); } };
et dans A( const A& other ) : b = other.b->copy();
-- -------------------------------------------- Benoît Rousseau : roussebe at spray dot se Jouez en programmant : http://realtimebattle.sourceforge.net/
Outils1
"Benoit Rousseau" a écrit dans le message news: 3fe30e1c$0$17869$
tu peux créer une fonction abstraire dans B qui retourne une nouvelle copie de l'objet à copier :
class B { B* copy() = 0; };
class C : public B { B* copy() { return new C( *this ) ; } //appel constructeur C(const C&) };
class D : public B { B* copy() { return new D(...); } };
et dans A( const A& other ) : b = other.b->copy();
C'est effectivement la conclusion à laquelle j'étais arrivé, mais je voulais être sur que c'était bien quelque chose de "normal" et qu'il n'y avait rien d'aberrant à cela... Merci à tous les deux :)
"Benoit Rousseau" <not.provided@no.spam> a écrit dans le message news:
3fe30e1c$0$17869$ba620e4c@reader5.news.skynet.be...
tu peux créer une fonction abstraire dans B qui retourne une nouvelle
copie de l'objet à copier :
class B {
B* copy() = 0;
};
class C : public B {
B* copy() { return new C( *this ) ; } //appel constructeur C(const C&)
};
class D : public B {
B* copy() { return new D(...); }
};
et dans A( const A& other ) :
b = other.b->copy();
C'est effectivement la conclusion à laquelle j'étais arrivé, mais je voulais
être sur que c'était bien quelque chose de "normal" et qu'il n'y avait rien
d'aberrant à cela...
Merci à tous les deux :)
"Benoit Rousseau" a écrit dans le message news: 3fe30e1c$0$17869$
tu peux créer une fonction abstraire dans B qui retourne une nouvelle copie de l'objet à copier :
class B { B* copy() = 0; };
class C : public B { B* copy() { return new C( *this ) ; } //appel constructeur C(const C&) };
class D : public B { B* copy() { return new D(...); } };
et dans A( const A& other ) : b = other.b->copy();
C'est effectivement la conclusion à laquelle j'étais arrivé, mais je voulais être sur que c'était bien quelque chose de "normal" et qu'il n'y avait rien d'aberrant à cela... Merci à tous les deux :)
