In che modo una classe C++ derivata può clonare se stessa tramite un puntatore di base?

Question

Ecco quello che sto cercando di fare (questo codice non funziona):

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(); 

quello che avevo come è quello di vedere "derivata" stampato ... quello che ottengo è "BASE ". Sono un programmatore C di lunga data e abbastanza esperto di C++ ... ma non sto facendo progressi con questo ... ogni aiuto sarebbe apprezzato.

Answer 1

Sei slicing della classe in Base bp = &d; (questo costruisce un nuovo bp base dal PTR-derivato.)

Prova Base* bp = &d; invece. (Vale a dire creare un puntatore di tipo Base per l'oggetto derivato.)

Answer 2

Con Base bp = &d;

Hai "affettato" d, in modo da al compilatore, bp è in realtà solo di tipo Base, motivo per cui quando si chiama il bp->clone() il compilatore chiama Base::clone(); e bp2->ID() stampe BASE.

Base& bp = d; farà quello che vuoi.

Answer 3

Il vostro esempio non è corretto e non verrà compilato. In particolare questa linea:

Base bp = &d; 

che può anche essere la causa principale del problema (si può essere affettando l'oggetto), ma non posso dirlo con certezza senza vedere il codice di lavoro.

Hai anche un problema in cui i tuoi due classi non sono correlati (Cercavi scrivere class Derived : public Base?)

Answer 4

Quel codice è pieno di errori di sintassi. Forse la cosa più significativa, Derived non eredita da Base. In secondo luogo, a parte gli errori sintattici (probabilmente semplici errori di battitura), Base ha ovviamente bisogno di un distruttore virtuale. Il metodo clone richiede praticamente di poter chiamare l'operatore delete su un puntatore di 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

Una volta che tutti gli errori di compilazione sono fissi, ho finito con questo:

#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(); 
} 

che ti dà quello che state cercando - DERIVATI.

Answer 6

Il codice sembra buono, a parte gli errori di sintassi stupidi e i sensori mancanti.