Salve a tutti!
oggi, oltre al caldo,c'è un'altra cosa che mi tormenta:un crash che proprio non mi spiego!
Sto lavorando su una struttura, un albero ennario realizzato con puntatore. Faccio uno scrivinodo e tutto va bene, ma quando vado a leggere il nodo ho questo crash. Volete darci un'occhiata per favore?
Il crash si ha quando parte l'istruzione legginodo nel metodo testaalberi della classe base.

Albero nario con punt.
codice:
#ifndef albennariopunt_h
#define albennariopunt_h
#include <stdlib.h>
#include <iostream>
#include "nodoalberoennario.h"

using namespace std;

template <class tipoelem>
class albennariopunt : public alberoennebase <tipoelem, nodoalberoennario<tipoelem> * >
{
  public:
         typedef nodoalberoennario<tipoelem> *nodo;
         albennariopunt();
         void creaalbero();      
         bool alberovuoto();
         nodo radice();
         void insradice(nodo);
         nodo padre(nodo);
         bool foglia(nodo);
         nodo primofiglio(nodo);
         bool ultimofratello(nodo);
         nodo succfratello(nodo);
         tipoelem legginodo(nodo);
         void scrivinodo(tipoelem, nodo);
         void insprimosottoalbero(nodo);
         void inssottoalbero(nodo);
         void cancsottoalbero(nodo);
  private:
         nodo root;
};
#endif


template <class tipoelem> //costruttore
albennariopunt<tipoelem>::albennariopunt() 
{
  creaalbero();                                           
}

template <class tipoelem> //creaalbero
void albennariopunt<tipoelem>::creaalbero()
{
  root=NULL;
}

template <class tipoelem> //alberovuoto
bool albennariopunt<tipoelem>::alberovuoto() 
{
  return (root==NULL);     
}

template <class tipoelem> //radice
typename albennariopunt<tipoelem>::nodo albennariopunt<tipoelem>::radice() 
{
  return (root);         
}


template <class tipoelem> //insradice
void albennariopunt<tipoelem>::insradice(typename albennariopunt<tipoelem>::nodo x)
{
  if (alberovuoto())
    {
     x=new nodoalberoennario<tipoelem>;
     root=x;
     x->setpadre(NULL);
     x->setfiglio(NULL);
     x->setfratello(NULL);
    }
}

template <class tipoelem> //padre
typename albennariopunt<tipoelem>::nodo albennariopunt<tipoelem>::padre (typename albennariopunt<tipoelem>::nodo x)
{
// if ( (!alberovuoto()) && (x!=root) )
  return ( x->getpadre() );
 //else cout<<"errore"<<"\n";
}

template <class tipoelem> //foglia
bool albennariopunt<tipoelem>::foglia (typename albennariopunt<tipoelem>::nodo x)
{
 if (!alberovuoto())
  return (x->getfiglio()==NULL);     
}

template <class tipoelem> //primofiglio
typename albennariopunt<tipoelem>::nodo albennariopunt<tipoelem>::primofiglio (typename albennariopunt<tipoelem>::nodo x)
{
 if ( (!foglia(x)) && (!alberovuoto()) )
   return (x->getfiglio());
}

template <class tipoelem> //ultimofratello
bool albennariopunt<tipoelem>::ultimofratello(typename albennariopunt<tipoelem>::nodo x)
{
 if (!alberovuoto())
  return (x->getfratello()==NULL);     
}

template <class tipoelem> //succfratello
typename albennariopunt<tipoelem>::nodo albennariopunt<tipoelem>::succfratello(typename albennariopunt<tipoelem>::nodo x)
{
 if ( (!alberovuoto()) && (!ultimofratello(x)) )
  return (x->getfratello());
}

template <class tipoelem> //legginodo
tipoelem albennariopunt<tipoelem>::legginodo(typename albennariopunt<tipoelem>::nodo x)
{
 return (x->getetichetta());         
}

template <class tipoelem> //scrivinodo
void albennariopunt<tipoelem>::scrivinodo(tipoelem elem, nodo x)
{
 x->setetichetta(elem);     
}


template <class tipoelem> //insprimosottoalbero
void albennariopunt<tipoelem>::insprimosottoalbero (typename albennariopunt<tipoelem>::nodo x)
{
 nodo y;
 y=new nodoalberoennario<tipoelem>;
 
 if ( (!alberovuoto()) && ( this->radice()!=NULL) )
 { 
   y->setpadre(x);
   y->setfratello(x->getfiglio());
   x->setfiglio(y);
 }    
}

template <class tipoelem> //inssottoalbero
void albennariopunt<tipoelem>::inssottoalbero(typename albennariopunt<tipoelem>::nodo x)
{
 nodo y;
 y=new nodoalberoennario<tipoelem>;
 
 if ( (!alberovuoto()) && (x!=root) ) 
 { 
  if ( (x->getfiglio())!=NULL )
  {
   y->setfratello(x->getfratello());    
   y->setpadre(x->getpadre());
   x->setfratello(y);
  }
 }
}


template <class tipoelem> //cancsottoalbero
void albennariopunt<tipoelem>::cancsottoalbero(typename albennariopunt<tipoelem>::nodo x)
{
 if (!alberovuoto())
 {
   nodo temp;
   if (!foglia(x))
   {
     temp=primofiglio(x);
     while (!ultimofratello(temp))
     {  
       cancsottoalbero(temp);
       temp=succfratello(temp);                  
     }
   }
   if (x==root)
     root=NULL;
 delete x;
 }     
}
classe base
codice:
#ifndef alberoennebase_h
#define alberoennebase_h
#include <stdlib.h>
#include <iostream>

using namespace std;

template <class tipoelem, class nodo>
class alberoennebase
{
      public:
             virtual void creaalbero()=0;      
             virtual bool alberovuoto()=0;
             virtual nodo radice()=0;
             virtual void insradice(nodo)=0;
             virtual nodo padre(nodo)=0;
             virtual bool foglia(nodo)=0;
             virtual nodo primofiglio(nodo)=0;
             virtual bool ultimofratello(nodo)=0;
             virtual nodo succfratello(nodo)=0;
             virtual tipoelem legginodo(nodo)=0;
             virtual void scrivinodo(tipoelem, nodo)=0;
             virtual void insprimosottoalbero(nodo)=0;
             virtual void inssottoalbero(nodo)=0;
             virtual void cancsottoalbero(nodo)=0;
             
             void testalberi();
              
      
};
#endif

template <class tipoelem, class nodo>
void alberoennebase<tipoelem, nodo>::testalberi()
{
  nodo x,y;
  
  cout<<"Test albero vuoto(esito previsto 1): "<<this->alberovuoto()<<"\n"; 
  
  cout<<"Test insradice. \n";
  this->insradice(x); //test insradice
  cout<<"Test radice: "<<this->radice()<<"\n"; //test radice

  cout<<"Test inssottoalbero.";
  this->inssottoalbero(x);
  cout<<"Test scrivinodo,scrivo 2.";
  this->scrivinodo(2, x); //test scrivinodo
  cout<<"Test legginodo sul nodo appena scritto:"<<this->legginodo(x)<<"\n";
  
}
classe nodo
codice:
#ifndef nodoalberoennario_h
#define nodoalberoennario_h
#include <iostream>
#include <stdlib.h>

using namespace std;

template <class tipoelem>
class nodoalberoennario
{
   public:
          typedef nodoalberoennario *pos;
          
          nodoalberoennario();
          tipoelem getetichetta();
          pos getpadre();
          pos getfiglio();
          pos getfratello();
          
          void setetichetta(tipoelem);
          void setpadre(pos);
          void setfiglio(pos);
          void setfratello(pos);
          
          nodoalberoennario operator= (nodoalberoennario); //overloading dell'operatore =, necessario in futuro per assegnare due nodi
   private:
           tipoelem elem;          
           pos padre,figlio,fratello;
};
#endif

template <class tipoelem> //costruttore
nodoalberoennario<tipoelem>::nodoalberoennario()
{
  elem=0;                                              
  padre=NULL;
  figlio=NULL;
  fratello=NULL;                                                
}

template <class tipoelem> //getetichetta
tipoelem nodoalberoennario<tipoelem>::getetichetta()
{
 return  elem;                                
}

template <class tipoelem> //getpadre
typename nodoalberoennario<tipoelem>::pos nodoalberoennario<tipoelem>::getpadre()
{
 return padre;         
}

template <class tipoelem> //getfiglio
typename nodoalberoennario<tipoelem>::pos nodoalberoennario<tipoelem>::getfiglio()
{
 return figlio;        
}

template <class tipoelem> //getfratello
typename nodoalberoennario<tipoelem>::pos nodoalberoennario<tipoelem>::getfratello()
{
 return fratello;         
}

template <class tipoelem> //setetichetta
void nodoalberoennario<tipoelem>::setetichetta (tipoelem x)
{
 elem=x;     
}

template <class tipoelem> //setpadre
void nodoalberoennario<tipoelem>::setpadre(pos x)
{
 padre=x;     
}

template <class tipoelem> //setfiglio
void nodoalberoennario<tipoelem>::setfiglio(pos x)
{
 figlio=x;     
}

template <class tipoelem> //setfratello
void nodoalberoennario<tipoelem>::setfratello(pos x)
{
 fratello=x;     
}

template <class tipoelem>
nodoalberoennario<tipoelem> nodoalberoennario<tipoelem>::operator= (nodoalberoennario<tipoelem> x)
{
 padre=x.getpadre();
 figlio=x.getfiglio();
 fratello=x.getfratello();                            
}