C++: ¿Podrían los constructores de copias polimórficas funcionar?

Question

considerar:

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++ romperse si "nueva A (b1)" fue capaz de resolver a la creación de una nueva copia B y devolver una A?

¿Esto podría ser útil?

Answer 1

¿Necesita esta funcionalidad, o es solo un experimento mental?

Si necesita hacer esto, el idioma común es tener un método 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.

Hay varias formas de implementar la clonación (por ejemplo, el método clone() más o menos estándar, variaciones parametrizadas de fábricas de objetos, con o sin inyección de dependencia configurable) sin cambiar el significado de los programas existentes, o es imposible crear instancias de clases base cuando se conoce una clase derivada dentro de una unidad de compilación.

Los constructores y los destructores son lo suficientemente complejos como para ser entendidos por los principiantes. Inyectar aún más complejidad en ellos sería imprudente.

Answer 3

La expresión

new A(*b1) 

ya tiene un significado, suponiendo que tenía la sobrecarga apropiada.

Si se le dio un significado diferente, tendría que proporcionar otra forma de obtener el otro significado. Esta es una especie de sentido dado que ya hay una manera de conseguir el significado que desea:

new B(*b1) 

Y supongo que es más fáciles de interpretar.

Answer 4

Lo que realmente está buscando se llama virtual copy constructor, y lo publicado por eduffy es la forma estándar de hacerlo.

También hay clever ways of doing it with templates. (descargo de responsabilidad: autopromoción)

Answer 5

Como se señaló anteriormente, hay varias maneras de implementar esto.

Para responder a su pregunta si new A(*b1) devolvió una nueva instancia de B, esto no funcionaría.

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

Sólo una pequeña adición a la respuesta por eduffy: En lugar de

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

};

se puede declarar así:

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

};

Todavía es considerado un primordial válida de lo virtual A::Clone(); y es mejor si es llamado directamente a través B *