Comment une classe C++ dérivée peut-elle se cloner via un pointeur de base?

Question

Voici ce que je suis en train de faire (ce code ne fonctionne pas):

class Base 
{ 
    virtual Base *clone() { return new Base(this); } 
    virtual void ID() { printf("BASE"); 
}; 

class Derived : publc Base 
{ 
    virtual Base *clone() { return new Derived(this); } 
    virtual void ID() { printf("DERIVED"); } 
} 

. 
. 
Derived d; 
Base *bp = &d; 
Base *bp2 = bp->clone(); 

bp2->ID(); 

Ce que je comme est de voir « Dérivée » imprimé ... ce que je reçois est « BASE ". Je suis un programmeur C de longue date, et assez expérimenté avec le C++ ... mais je ne fais pas de progrès avec celui-ci ... toute aide serait appréciée.

Answer 1

Vous êtes slicing la classe Base bp = &d; (ce construit une nouvelle base pb de la dérivée-PTR.)

Essayez Base* bp = &d; à la place. (Par exemple créer un pointeur de type base de l'objet dérivé.)

Answer 2

Avec Base bp = &d;

Vous avez « découpé en tranches » d, ainsi que le compilateur, bp est vraiment seulement de type Base, ce qui est pourquoi, lorsque vous appelez bp->clone() le compilateur appelle Base::clone(); et bp2->ID() imprime BASE.

Base& bp = d; fera ce que vous voulez.

Answer 3

Votre exemple est incorrect et ne sera pas compilé. Plus précisément cette ligne:

Base bp = &d; 

Cela peut aussi être la cause de votre problème (vous pouvez être tranchage votre objet), mais je ne peux pas dire avec certitude sans voir le code de travail.

Vous avez également un problème où vos deux classes ne sont pas liés (avez-vous l'intention d'écrire class Derived : public Base?)

Answer 4

Ce code est truffé d'erreurs syntaxiques. Peut-être le plus important, Derived n'hérite pas de Base. Deuxièmement, mis à part les erreurs syntaxiques (probablement de simples fautes de frappe), Base a évidemment besoin d'un destructeur virtuel. La méthode clone exige à peu près que vous puissiez appeler l'opérateur delete sur un pointeur de base (Base *).

class Base 
{ 
public: 
    virtual ~Base() {} 
    virtual Base* clone() const { return new Base(*this); } 
    virtual void ID() const { printf("BASE"); } 
}; 

class Derived: public Base 
{ 
public: 
    // [Edit] Changed return type to Derived* instead of Base*. 
    // Thanks to Matthieu for pointing this out. @see comments below. 
    virtual Derived* clone() const { return new Derived(*this); } 
    virtual void ID() const { printf("DERIVED"); } 
}; 

int main() 
{ 
    Derived d; 
    Base* bp = &d; 

    Base* bp2 = bp->clone(); 
    bp2->ID(); // outputs DERIVED as expected 
    delete bp2; 
} 

Answer 5

Une fois que toutes les erreurs de compilation sont fixes, j'ai fini avec ceci:

#include <cstdio> 

class Base 
{ 
    public: 
    Base() {} 
    Base(const Base&) {} 
    virtual Base *clone() { return new Base(*this); } 
    virtual void ID() { printf("BASE"); } 
}; 

class Derived : public Base 
{ 
    public: 
    Derived() {} 
    Derived(const Derived&) {} 
    virtual Base *clone() { return new Derived(*this); } 
    virtual void ID() { printf("DERIVED"); } 
}; 


int main() 
{ 
    Derived d; 
    Base *bp = &d; 
    Base *bp2 = bp->clone(); 

    bp2->ID(); 
} 

Ce qui vous donne ce que vous cherchez - DÉRIVÉS.

Answer 6

Le code a l'air bien, autre que les fautes de syntaxe stupides et les ctors manquants.