Tengo una duda, la siguiente función puede recibir un objeto de tipo A o algo derivado del tipo.Usando un nuevo operador para copiar un objeto en un montón sin conocer su tipo
A *copyToHeap(A &obj) {
A *ptr=new A(obj);
return ptr;
}
Si lo llamamos así:
//B inherits from A
B bObj;
B *hPtr=copyToHeap(bObj);
El objeto apuntado por hPtr es en realidad de tipo A o B? ¿Está seguro haciendo esto?
cuando lo hace el siguiente en el código:
A* ptr = new A(obj);
que siempre obtendrá una A instancia. obj se tratará como A y se creará una nueva A en función de la "parte A" de obj.
El mejor enfoque es como se indicó en una respuesta anterior, agrega un método virtual de MakeCopy a la clase base y lo implementa para las clases derivadas.
virtual A* MakeCopy();
Este método se implementa haciendo una copia del objeto para el que se llama. Luego se implementa en las clases derivadas por lo que si tiene un puntero A que es realmente un objeto B obtendrá una copia B verdadera y evitará el "corte" que está ocurriendo en su ejemplo.
El objeto devuelto es del tipo pointer to A, lo que significa que el objeto apuntado por hPtr es del tipo A. No es seguro ya que los métodos de llamada o miembros exclusivos de B causarán un bloqueo o un comportamiento indefinido. Probablemente estés buscando el factory pattern.
No es seguro, es incorrecto, y el compilador debe darle algunos diagnósticos. ¿Intentó compilar con g++ -Wall si usa GCC?
Una forma segura es proporcionar un método clon virtual
#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();
}
no se compila:
B *hPtr=copyToHeap(bObj); //error: invalid conversion from ‘A*’ to ‘B*’
Si cambia el tipo de hPtr a A* compila, pero todavía se obtiene una A objeto. El constructor de copiado predeterminado para A que utilice creará un objeto A y copiará los campos del objeto B que se definieron en A, cortando la parte B desactivada.
Debido a todos los problemas descritos anteriormente/en esta publicación, si puede evitarlo (y no puedo pensar en una razón por la que no pudo), no debe diseñar su código para requerir "copyToHeap".
Como señala Luchian, es probable que desee una fábrica. La fábrica crea su objeto en el montón para comenzar (y devuelve un puntero inteligente para administrar la vida útil del objeto/puntero/memoria).
Lo siento, escribí el código de memoria y no pude tratar de comile. – jlledom