C/C++ - costruttore copia di una classe autoriferente

Salve sto provando ad implementare una classe che astrae il concetto di nodo di un albero generico, il codice è questo:

template <class T>
class Node
{
    public:
        Node();
        ~Node();
        Node(const Node& other); //costruttore copia
        Node& operator=(const Node& other);
    protected:
    private:
        Node* parent;
        Node* left , right;
        T data;
};

ma non so bene come implementare il costruttore copia, avevo pesato ad una cosa del genere:

   Node copyNode = new Node();
    copyNode.parent = other.parent;
   copyNode.left = other.left;
   copyNode.right = other.right;
  copyNode.data = other.data;

Ma non sono sicuro che sia così per il fatto che non sono certo se si debba allocare un nuovo nodo oppure si debba allocare un nuovo nodo sia per parent sia per left sia per right.
Un aiuto?

Dipende dall'uso che vuoi fare della copia. nel caso tu copiassi un nodo e richiamassi la copia anche per parent, left e right ti troveresti in una condizione di loop, in quanto il right, ad esempio, cercherebbe di copiare il parent finendo a riempire tutta la ram e non potendo completare la copia.

Se il nodo copia deve essere sostituibile a piacere ha senso copiare solo il nodo (chiaramente poi implica il fatto di dover cambiare il padre):

  Node root = new Node();
  root.right = new Node();
  Node newRight = new Node(root.right);
  // newRight è copia solo del nodo e non è associata a root.right
  root.right = newRight; // Cambio il nodo vecchio con il nuovo nella struttura
  // I figli sono gli stessi, quindi ho solo cambiato il nodo

Altrimenti il significato di copia "deep" potrebbe intendere la ricostruzione della parte di albero sottostante, ossia la copia è una vera copia di tutti i figli:

Node(const Node& other) {
  this.parent = other.parent;
  this.right = new Node(other.right);
  this.left = new Node(other.left);
}

A questo punto la copia consiste in un nuovo sottoalbero con radice uguale al nodo e permette utilizzi differenti al primo metodo:

  Node root = new Node();
  root.right = new Node();
  root.left = new Node(root.right); // Copia la struttura di destra a sinistra (i figli di right e left sono effettivamente differenti)

Ho notato che, per esempio in jQuery, la funzione per clonare un nodo solitamente prevede due parametri, proprio per permettere entrambi i tipi di copia (anche se nel caso di copia normale si tende a rimuovere i nodi figli)

Node(const Node& other, bool deep);

Anche se il contesto e l'uso sono completamente differenti ti consiglio di guardare il concetto di copia presentato su api.jquery.com/clone/