ciao a tutti, sto creando la struttura albero binario di ricerca ma ho un problema col costruttore. in pratica l'albero binario di ricerca è una classe derivata di albero binario e implementa ulteriori metodi. in pratica mi viene segnalato un errore al costruttore dell'albero binario di ricerca. posto i codici:

nodoalberop.h
codice:
#ifndef nodoalberop_h
#define nodoalberop_h

#include<iostream>
#include<stdlib.h>

using namespace std;

template<class tipoelem>
class nodoalberop
{
   public:
      nodoalberop();
      
      void setpadre(nodoalberop *);
      void setfigliosx(nodoalberop *);
      void setfigliodx(nodoalberop *);
      void setetichetta(tipoelem);
      
      nodoalberop *getpadre();
      nodoalberop *getfigliosx();
      nodoalberop *getfigliodx();
      tipoelem getetichetta();
      
      nodoalberop operator=(nodoalberop);
      
      int livello;
   private:
      nodoalberop *padre;
      nodoalberop *figliosx;
      nodoalberop *figliodx;
      tipoelem etichetta;
};

#endif

template<class tipoelem>
nodoalberop<tipoelem>::nodoalberop()
{
   padre = NULL;
   figliosx = NULL;
   figliodx = NULL;
   etichetta = 0;
   livello = -1;
}

template<class tipoelem>
void nodoalberop<tipoelem>::setpadre(nodoalberop<tipoelem> *p)
{
   padre = p;
}

template<class tipoelem>
void nodoalberop<tipoelem>::setfigliosx(nodoalberop<tipoelem> *fsx)
{
   figliosx = fsx;
}

template<class tipoelem>
void nodoalberop<tipoelem>::setfigliodx(nodoalberop<tipoelem> *fdx)
{
   figliodx = fdx;
}

template<class tipoelem>
void nodoalberop<tipoelem>::setetichetta(tipoelem elem)
{
   etichetta = elem;
}

template<class tipoelem>
nodoalberop<tipoelem>::nodoalberop<tipoelem> *nodoalberop<tipoelem>::getpadre()
{
   return(padre);
}

template<class tipoelem>
nodoalberop<tipoelem>::nodoalberop<tipoelem> *nodoalberop<tipoelem>::getfigliosx()
{
   return(figliosx);
}

template<class tipoelem>
nodoalberop<tipoelem>::nodoalberop<tipoelem> *nodoalberop<tipoelem>::getfigliodx()
{
   return(figliodx);
}

template<class tipoelem>
tipoelem nodoalberop<tipoelem>::getetichetta()
{
   return(etichetta);
}

template<class tipoelem>
nodoalberop<tipoelem> nodoalberop<tipoelem>::operator=(nodoalberop<tipoelem> node)
{
   this->setpadre(node.getpadre());
   this->setfigliosx(node.getfigliosx());
   this->setfigliodx(node.getfigliodx());
   this->setetichetta(node.getetichetta());
}
alberobinp.h
codice:
#ifndef alberobinp_h
#define alberobinp_h

#include "nodoalberop.h"
#include<assert.h>
#include<iostream>
#include<stdlib.h>

using namespace std;

template<class tipoelem>
class alberobinp
{
   public:
      typedef nodoalberop<tipoelem> *nodo;
      alberobinp();
      
      void creabinalbero();
      bool binalberovuoto();
      nodo binradice();
      nodo binpadre(nodo);
      nodo figliosx(nodo);
      nodo figliodx(nodo);
      bool sxvuoto(nodo);
      bool dxvuoto(nodo);
      tipoelem legginodo(nodo);
      void scrivinodo(nodo, tipoelem);
      void insbinradice(nodo);
      void insfigliosx(nodo);
      void insfigliodx(nodo);
      void cancsottoalbero(nodo);
   protected:
      nodo radice;
};

#endif

template<class tipoelem>
alberobinp<tipoelem>::alberobinp()
{
   this->creabinalbero();
}

template<class tipoelem>
void alberobinp<tipoelem>::creabinalbero()
{
   radice = NULL;
}

template<class tipoelem>
bool alberobinp<tipoelem>::binalberovuoto()
{
   return(radice == NULL);
}

template<class tipoelem>
typename alberobinp<tipoelem>::nodo alberobinp<tipoelem>::binradice()
{
   assert(!this->binalberovuoto());
   return(radice);
}

template<class tipoelem>
typename alberobinp<tipoelem>::nodo alberobinp<tipoelem>::binpadre(typename alberobinp<tipoelem>::nodo node)
{
   assert(!this->binalberovuoto() && (node != radice));
   return(node->getpadre());
}

template<class tipoelem>
typename alberobinp<tipoelem>::nodo alberobinp<tipoelem>::figliosx(typename alberobinp<tipoelem>::nodo node)
{
   assert(!this->binalberovuoto() && !this->sxvuoto(node));
   return(node->getfigliosx());
}

template<class tipoelem>
typename alberobinp<tipoelem>::nodo alberobinp<tipoelem>::figliodx(typename alberobinp<tipoelem>::nodo node)
{
   assert(!this->binalberovuoto() && !this->dxvuoto(node));
   return(node->getfigliodx());
}

template<class tipoelem>
bool alberobinp<tipoelem>::sxvuoto(typename alberobinp<tipoelem>::nodo node)
{
   assert(!this->binalberovuoto());
   return(node->getfigliosx() == NULL);
}

template<class tipoelem>
bool alberobinp<tipoelem>::dxvuoto(typename alberobinp<tipoelem>::nodo node)
{
   assert(!this->binalberovuoto());
   return(node->getfigliodx() == NULL);
}

template<class tipoelem>
tipoelem alberobinp<tipoelem>::legginodo(typename alberobinp<tipoelem>::nodo node)
{
   return(node->getetichetta());
}

template<class tipoelem>
void alberobinp<tipoelem>::scrivinodo(typename alberobinp<tipoelem>::nodo node, tipoelem elem)
{
   node->setetichetta(elem);
}

template<class tipoelem>
void alberobinp<tipoelem>::insbinradice(typename alberobinp<tipoelem>::nodo node)
{
   assert(this->binalberovuoto());
   radice = node;
}

template<class tipoelem>
void alberobinp<tipoelem>::insfigliosx(typename alberobinp<tipoelem>::nodo node)
{
   assert(!this->binalberovuoto() && this->sxvuoto(node));
   nodo temp = new nodoalberop<tipoelem>;
   node->setfigliosx(temp);
   temp->setpadre(node);
}

template<class tipoelem>
void alberobinp<tipoelem>::insfigliodx(typename alberobinp<tipoelem>::nodo node)
{
   assert(!this->binalberovuoto() && this->dxvuoto(node));
   nodo temp = new nodoalberop<tipoelem>;
   node->setfigliodx(temp);
   temp->setpadre(node);
}

template<class tipoelem>
void alberobinp<tipoelem>::cancsottoalbero(alberobinp<tipoelem>::nodo node)
{
   if(node->getfigliosx() != NULL)
      this->cancsottoalbero(node->getfigliosx());
   if(node->getfigliodx() != NULL)
      this->cancsottoalbero(node->getfigliodx());
   if(node == this->binradice())
      radice = NULL;   
   delete node;
}


segue--->