ciao a tutti ho creato la struttura albero binario con vettore, puntatore e cursore; inoltre ho creato una classe base con dei metodi che funzionano con tutti e tre i tipi di realizzazione. in pratica, quando faccio il test con l'albero con cursore (penso dia lo stesso problema anche con le altre realizzazioni) e arrivo al metodo visitaampiezza(), va in crash l'esecuzione. posto i codici.

codap.h
codice:
#ifndef codap_h
#define codap_h

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

using namespace std;

template<class tipoelem>
class codap
{
   public:
      codap();
      
      void creacoda();
      bool codavuota();
      tipoelem leggicoda();
      void incoda(tipoelem);
      void fuoricoda();
   private:
      nodop<tipoelem> *testa;
      nodop<tipoelem> *coda;
};

#endif

template<class tipoelem>
codap<tipoelem>::codap()
{
   this->creacoda();
}

template<class tipoelem>
void codap<tipoelem>::creacoda()
{
   testa = NULL;
   coda = NULL;
}

template<class tipoelem>
bool codap<tipoelem>::codavuota()
{
   return((testa == NULL) && (coda == NULL));
}

template<class tipoelem>
tipoelem codap<tipoelem>::leggicoda()
{
   return(testa->getelem());
}

template<class tipoelem>
void codap<tipoelem>::incoda(tipoelem elem)
{
   nodop<tipoelem> *tmp = new nodop<tipoelem>;
   
   if(this->codavuota())
   {
      tmp->setprec(NULL);
      tmp->setsuc(NULL);
      testa = tmp;
      coda = tmp;
   }
   else
   {
      coda->setprec(tmp);
      tmp->setprec(NULL);
      tmp->setsuc(coda);
   }
   tmp->setelem(elem);
   coda = tmp;
}

template<class tipoelem>
void codap<tipoelem>::fuoricoda()
{
   if(!this->codavuota())
   {
      nodop<tipoelem> *tmp = new nodop<tipoelem>;
      tmp = testa;
      testa = testa->getprec();
      testa->setsuc(NULL);
   }
   else
      cerr << "la coda e' vuota.\n\n";
}
alberobin.h
codice:
#ifndef alberobin_h
#define alberobin_h

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

using namespace std;

template<class nodo, class tipoelem>
class alberobin
{
   public:
      virtual void creabinalbero() = 0;
      virtual bool binalberovuoto() = 0;
      virtual nodo binradice() = 0;
      virtual nodo binpadre(nodo) = 0;
      virtual nodo figliosx(nodo) = 0;
      virtual nodo figliodx(nodo) = 0;
      virtual bool sxvuoto(nodo) = 0;
      virtual bool dxvuoto(nodo) = 0;
      virtual tipoelem legginodo(nodo) = 0;
      virtual void scrivinodo(nodo, tipoelem) = 0;
      virtual void insbinradice(nodo) = 0;
      virtual void insfigliosx(nodo) = 0;
      virtual void insfigliodx(nodo) = 0;
      virtual void cancsottoalbero(nodo) = 0;
      
      void test();
      void visitaampiezza();
      void previsita(nodo);
      void postvisita(nodo);
      void simmvisita(nodo);
};

#endif

template<class nodo, class tipoelem>
void alberobin<nodo, tipoelem>::test()
{
   cout << "                          ***test metodo CREABINALBERO***\n\n";
   cout << "il metodo CREABINALBERO crea un albero binario vuoto. per provare\n";
   cout << "la correttezza del metodo basta invocar eil metodo BINALBEROVUOTO\n";
   cout << "il quale deve dare come risulatato il valore booleano vero (1).\n\n";
   cout << "   binalberovuoto() = " << this->binalberovuoto() << "\n\n";
   system("pause");
   system("cls");
   
   cout << "                          ***test del metodo BINALBEROVUOTO***\n\n";
   cout << "il metodo BINALBEROVUOTO testa se l'albero binario ho o meno nodi\n";
   cout << "(compresa la radice) fornendo un valore booleano a seconda della\n";
   cout << "presenza dei nodi.\n\n";
   cout << "   test con albero privo di nodi:\n";
   cout << "      binalberovuoto() = " << this->binalberovuoto() << "\n\n";
   cout << "   test con albero con almeno un nodo:\n";
   cout << "      inserimento della radice con un valore:\n";
   cout << "      radice = ";
   nodo node;
   tipoelem a;
   cin >> a;
   this->insbinradice(node);
   this->scrivinodo(this->binradice(), a);
   cout << "      binalberovuoto() = " << this->binalberovuoto() << "\n\n";
   system("pause");
   system("cls");
   
   cout << "                         ***test del metodo BINRADICE***\n\n";
   cout << "il metodo BINRADICE restituisce il riferimento alla radice\n";
   cout << "dell'albero binario.\n\n";
   cout << "   binradice() = " << this->binradice() << "\n\n";
   system("pause");
   system("cls");
   
   cout << "                         ***test del metodo BINPADRE***\n\n";
   cout << "il metodo BINPADRE restituisce il riferimento al nodo padre\n";
   cout << "del nodo fornito come argomento.\n\n";
   cout << "poiché l'albero è costituito dalla sola radice, la quale non\n";
   cout << "ha padre, bisogna inserire un ulteriore nodo come figlio sx o\n";
   cout << "dx della radice.\n\n";
   nodo temp;
   this->insfigliosx(this->binradice());
   cout << "   binpadre(figliosx(radice())) = " << this->binpadre(this->figliosx(this->binradice())) << "\n\n";
   system("pause");
   system("cls");
   
   cout << "                         ***test del metodo FIGLIOSX***\n\n";
   cout << "il metodo FIGLIOSX fornisce il nodo che è figlio sinistro del\n";
   cout << "nodo passato come argomento.\n\n";
   cout << "   figliosx(radice()) = " << this->figliosx(this->binradice()) << "\n\n";
   system("pause");
   system("cls");
   
   cout << "                         ***test del metodo FIGLIODX***\n\n";
   cout << "analogo al metodo FIGLIODX\n\n";
   nodo tmp2;
   this->insfigliodx(this->binradice());
   cout << "   figliodx(radice()) = " << this->figliodx(this->binradice()) << "\n\n";
   system("pause");
   system("cls");
   
   cout << "                        ***test del metodo SXVUOTO***\n\n";
   cout << "il metodo SXVUOTO fornisce un valore booleano a seconda che il\n";
   cout << "nodo passato come argomento ha o meno figlio sinistro.\n\n";
   cout << "   test con esito positivo:\n";
   cout << "      sxvuoto(figliosx(radice())) = " << this->sxvuoto(this->figliosx(this->binradice())) << "\n\n";
   cout << "   test con esito negativo:\n";
   cout << "      sxvuoto(radice()) = " << this->sxvuoto(this->binradice()) << "\n\n";
   
   system("pause");
   system("cls");
   
   cout << "                        ***test del metodo DXVUOTO***\n\n";
   cout << "analogo al metodo SXVUOTO.\n\n";
   cout << "   test con esito positivo:\n";
   cout << "      dxvuoto(figliosx(radice())) = " << this->dxvuoto(this->figliosx(this->binradice())) << "\n\n";
   cout << "   test con esito negativo:\n";
   cout << "      dxvuoto(radice()) = " << this->dxvuoto(this->binradice()) << "\n\n";
   system("pause");
   system("cls");
   
   cout << "                       ***test dei metodi SCRIVINODO e LEGGINODO***\n\n";
   cout << "il metodo SCRIVINODO scrive un valore nell'etichetta del nodo\n";
   cout << "passato come argomento. il metodo LEGGINODO fornisce tale valore.\n\n";
   cout << "   scrittura nella radice di un valore: ";
   cin >> a;
   this->scrivinodo(this->binradice(), a);
   this->scrivinodo(this->figliosx(this->binradice()), 2);
   this->scrivinodo(this->figliodx(this->binradice()), 3);
   cout << "   lettura del valore della radice:\n";
   cout << "      legginodo(radice()) = " << this->legginodo(this->binradice()) << "\n\n";
   system("pause");
   system("cls");
   
   cout << "         ***metodi PREVISITA, POSTVISITA, SIMMETRICA e AMPIEZZA***\n\n";
   cout << "   previsita() = ";
   this->previsita(this->binradice());
   cout << "\n\n";
   cout << "   postvisita() = ";
   this->postvisita(this->binradice());
   cout << "\n\n   simmetrica() = ";
   this->simmvisita(this->binradice());
   cout << "\n\n   ampiezza() = ";
   this->visitaampiezza();
   cout << "\n\n";
   system("pause");
   system("cls");
   
   cout << "i metodi INSBINRADICE, INSFIGLIOSX e INSFIGLIODX sarebbero gia'\n";
   cout << "testati in quanto sono stati utilizzati per testare i metodi\n";
   cout << "BINRADICE, FIGLIOSX e FIGLIODX.\n\n";
   system("pause");
   system("cls");
   
   cout << "                      test del metodo CANCSOTTOALBERO***\n\n";
   cout << "il metodo CANCSOTTOALBERO cancella tutti i nodi dell'albero a partire\n";
   cout << "dal nodo passato come argomento. nel test viene cancellato tutto l'albero\n";
   cout << "e viene invocato il metodo BINALBEROVUOTO per verificare se il mtodo\n";
   cout << "ha funzionato correttamente.\n\n";
   cout << "   cancellazione dell'albero:\n";
   this->cancsottoalbero(this->binradice());
   cout << "   verifica: bianlberovuoto() = " << this->binalberovuoto() << "\n\n";
}

template<class nodo, class tipoelem>
void alberobin<nodo, tipoelem>::visitaampiezza()
{
   codap<nodo> Q;
   tipoelem a;
   nodo u = this->binradice();
   Q.incoda(u);
   while(!Q.codavuota())
   {
      u = Q.leggicoda();
      a = this->legginodo(u);
      cout << a << "  ";
      Q.fuoricoda();
      system("pause");
      if(!this->sxvuoto(u))
         Q.incoda(this->figliosx(u));
      if(!this->dxvuoto(u))
         Q.incoda(this->figliodx(u));
   }
}

template<class nodo, class tipoelem>
void alberobin<nodo, tipoelem>::previsita(nodo node)
{
   cout << this->legginodo(node) << "  ";
   if(!this->sxvuoto(node))
      this->previsita(this->figliosx(node));
   if(!this->dxvuoto(node))
      this->previsita(this->figliodx(node));
}

template<class nodo, class tipoelem>
void alberobin<nodo, tipoelem>::postvisita(nodo node)
{
   if(!this->sxvuoto(node))
      this->postvisita(this->figliosx(node));
   if(!this->dxvuoto(node))
      this->postvisita(this->figliodx(node));
   cout << this->legginodo(node) << "  ";
}

template<class nodo, class tipoelem>
void alberobin<nodo, tipoelem>::simmvisita(nodo node)
{
   if(!this->sxvuoto(node))
      this->simmvisita(this->figliosx(node));
   cout << this->legginodo(node) << "  ";
   if(!this->dxvuoto(node))
      this->simmvisita(this->figliodx(node));
}
CONTINUA----->