c++ - polimorfismo - herencia en java

C++ Llamando a un constructor de copia en una clase derivada desconocida a través de una clase base abstracta

Question

Estoy creando un árbol que tiene varios tipos de nodos diferentes: un nodo binario, un nodo unario y un nodo terminal. Tengo un ABC del que heredan todos los nodos. Estoy tratando de escribir un constructor de copia recursivo para el árbol, así:

class gpnode
{
public:
  gpnode() {};
  virtual ~gpnode() {};
  gpnode(const gpnode& src) {};

  gpnode* parent;
}

class bnode:gpnode
{
public:
  bnode() {//stuff};
  ~bnode() {//recursive delete};

  bnode(const bnode& src)
  {
    lnode = gpnode(src.lnode);
    rnode = gpnode(src.rnode);

    lnode->parent = this;
    rnode->parent = this;
  }

  gpnode* lnode;
  gpnode* rnode;
}

class unode:gpnode
{
public:
  unode() {//stuff};
  ~unode() {//recursive delete};

  unode(const unode& src)
  {
    node = gpnode(src.node);

    node->parent = this;
  }

  gpnode* node;
}

Mi problema es que no puedo hacer

node = gpnode(src.node);

porque gpnode es una clase virtual. Yo podría hacer

node = unode(src.node);

pero eso no funciona cuando el hijo de un inodo es un bnode. ¿Cómo hago para que llame inteligentemente al constructor de copias que necesito?

Answer 1

Debe implementar la clonación.

   class base
   {
   public:
       virtual base* clone() const = 0;
   }

   class derived : public base
   {
   public:
       derived(){}; // default ctor
       derived(const derived&){}; // copy ctor

       virtual derived* clone() const { return new derived(*this); };
   };

Etceteras

Answer 2

Para hacer esto, debe proporcionar un método de clone para sus objetos, que devuelva un puntero del tipo apropiado. Si todas sus clases tienen constructores de copia, eso es tan simple como eso:

node* clone() const {
    return new node(*this);
}

Donde node es la clase para la que está escribiendo el método de clone . Por supuesto, deberías declarar ese método en tu clase base:

virtual gpnode* clone() const = 0;

Answer 3

Use el constructor virtual .