C++: i costruttori di copia polimorfica potrebbero funzionare?

Question

Considerare:

class A 
{ 
public: 
    A(int val) : m_ValA(val) {} 
    A(const A& rhs) {} 
    int m_ValA; 
}; 

class B : public A 
{ 
public: 
    B(int val4A, int val4B) : A(val4A), m_ValB(val4B) {} 
    B(const B& rhs) : A(rhs), m_ValB(rhs.m_ValB) {} 
    int m_ValB; 
}; 

int main() 
{ 
    A* b1 = new B(1, 2); 
    A* b2 = new A(*b1); // ERROR...but what if it could work? 
    return 0; 
} 

Would C++ essere rotto se "nuovo A (b1)" è stato in grado di risolvere per la creazione di una nuova copia B e la restituzione di un A?

Questo potrebbe essere utile?

Answer 1

Hai bisogno di questa funzionalità o è solo un esperimento mentale?

Se avete bisogno di fare questo, l'idioma comune è quello di avere un metodo Clone:

class A 
{ 
public: 
    A(int val) : m_ValA(val) {} 
    A(const A& rhs) {} 
    virtual A *Clone() = 0; 
    int m_ValA; 
}; 

class B : public A 
{ 
public: 
    B(int val4A, int val4B) : A(val4A), m_ValB(val4B) {} 
    B(const B& rhs) : A(rhs), m_ValB(rhs.m_ValB) {} 
    A *Clone() { return new B(*this); } 
    int m_ValB; 
}; 

int main() 
{ 
    A* b1 = new B(1, 2); 
    A* b2 = b1->Clone(); 
    return 0; 
} 

Answer 2

Sì. No.

Esistono diversi modi per implementare la clonazione (ad esempio il metodo clone() più o meno standard, le variazioni parametrizzate delle fabbriche di oggetti, con o senza l'iniezione di dipendenza configurabile) senza modificare il significato dei programmi esistenti o effettuare impossibile creare istanze di classi base quando una classe derivata è nota all'interno di un'unità di compilazione.

Costruttori e distruttori sono sufficientemente complessi da comprendere per i principianti così come sono. Iniettare ancora più complessità in essi sarebbe poco saggio.

Answer 3

L'espressione

new A(*b1) 

ha già un significato, supponendo si aveva l'overload appropriato.

Se è stato assegnato un significato diverso, è necessario fornire un altro modo per ottenere l'altro significato. Questa è una specie di inutile dato che c'è già un modo per ottenere il significato che si desidera:

new B(*b1) 

E indovinate che è più chiaro da leggere.

Answer 4

Quello che stai veramente cercando è chiamato virtual copy constructor, e quale eduffy pubblicato è il modo standard per farlo.

Ci sono anche clever ways of doing it with templates. (disclaimer: auto-promozione)

Answer 5

Come sottolineato sopra ci sono diversi modi per implementarlo.

Per rispondere alla tua domanda se new A(*b1) ha restituito una nuova istanza di B, questo non funzionerebbe.

int main() 
{ 
    A* b1 = new B(1, 2); 
    A a(*b1); // What size would 'a' be if it was polymorphicly constructed? 
    return 0; 
} 

Answer 6

Basta una piccola aggiunta alla risposta da eduffy: Invece di

class B : public A { 
    ... 
    A *Clone() { return new B(*this); } 
    ... 

};

è possibile dichiarare in questo modo:

class B : public A { 
    ... 
    B *Clone() { return new B(*this); } // note: returning B * 
    ... 

};

E 'ancora considerato un imperativo valida del virtuale A::Clone(); ed è meglio se chiamato direttamente attraverso B *