Ho un dubbio, la funzione qui sotto può ricevere un oggetto di tipo A o qualcosa tipo derivato.Usando nuovo operatore per copiare un oggetto al mucchio senza conoscere il tipo
A *copyToHeap(A &obj) {
A *ptr=new A(obj);
return ptr;
}
Se chiamiamo così:
//B inherits from A
B bObj;
B *hPtr=copyToHeap(bObj);
l'oggetto puntato da hPtr è in realtà di tipo A o B? È sicuro farlo?
quando si esegue il seguito nel codice:
A* ptr = new A(obj);
otterrete sempre un Un'istanza. obj sarà trattato come un A e verrà creato un nuovo A basato sulla "Parte" di obj.
L'approccio migliore è come una risposta in precedenza indicato, aggiungere un metodo MakeCopy virtuale per la classe di base e mettere in atto per le classi derivate.
virtual A* MakeCopy();
Questo metodo è implementato facendo una copia dell'oggetto per cui la sua chiamata. Viene quindi implementato nelle classi derivate, quindi se si ha un puntatore A che è in realtà un oggetto B, si otterrà una copia B vera ed eviterà il "taglio" che si sta verificando nell'esempio.
L'oggetto restituito è di tipo pointer to A, che significa che l'oggetto indicato da hPtr è di tipo A. Non è sicuro poiché chiamare metodi o membri esclusivi di B causerà un arresto anomalo o un comportamento indefinito. Probabilmente stai cercando lo factory pattern.
non è sicuro, non è corretto, e il compilatore dovrebbe darvi alcune diagnostica. Hai provato a compilare con g++ -Wall se si utilizza GCC?
Un modo sicuro è quello di fornire un metodo clone virtuale
#include <memory>
class Base
{
public:
virtual std::unique_ptr<Base> Clone() = 0;
};
class Derived : public Base
{
public:
Derived(int i) : i_(i)
{
}
std::unique_ptr<Base> Clone()
{
return std::unique_ptr<Derived>(new Derived(i_));
}
private:
int i_;
};
std::unique_ptr<Base> copyToHeap(std::unique_ptr<Base> obj)
{
return obj->Clone();
}
Non compilare:
B *hPtr=copyToHeap(bObj); //error: invalid conversion from ‘A*’ to ‘B*’
Se si cambia il tipo di hPtr-A* si compila, ma è ancora ottenere un A oggetto. Il costruttore di copia di default per A che si usa creare un oggetto A e copiare i campi dell'oggetto B che sono stati definiti in A, affettare la parte B off.
A causa di tutti i problemi descritti sopra/in questo post - se non del tutto è possibile evitarlo (e non riesco a pensare a un motivo per cui non si possa) - non si dovrebbe progettare il codice per richiedere "copyToHeap".
Come Luchian sottolinea, probabilmente vuole una fabbrica. Il factory crea il tuo oggetto sull'heap all'inizio (e restituisce un puntatore intelligente per gestire la durata dell'oggetto/puntatore/memoria).
Mi dispiace, ho scritto il codice dalla memoria e non ho potuto provare a comile. – jlledom