[C++] Lista con cursori: visualizzazione degli elementi causa ciclo infinito

[pietrol83]

ciao, ho creato la struttura lista con cursori. nel test ho provato ad inserire 10 elementi (sempre in prima posizione) nelle lista tramite un ciclo for. subito dopo ho fatto un altro ciclo for per la visualizzazione a video degli elementi della lista, però il ciclo va all'infinito visualizzando solo il primo elemento della lista che in questo caso è 90. posto il codice della lista e del test:


listac.h

#ifndef listac_h
#define listac_h

#include <iostream>
#include <stdlib.h>
using namespace std;

const int LUNGVET = 100;

template<class tipoelem>
class listac
{
   public:
      typedef int posizione;
      
      listac();
      void crealista();
      bool listavuota();
      posizione primolista();
      bool finelista(posizione);
      posizione predlista(posizione);
      posizione succlista(posizione);
      tipoelem leggilista(posizione);
      void scrivilista(posizione, tipoelem);
      void inslista(posizione, tipoelem);
      void canclista(posizione);
   private:
      typedef struct nodo
      {
         posizione precedente;
         tipoelem elemento;
         posizione successivo;
      } nodo;
      static nodo *spazio;
      static posizione listalibera;
      static int lunglistalibera;
      static bool inizializzata;
      posizione lista;
      int lunglista;
           
      static nodo *inizializza();
      void sposta(posizione, posizione);
};
#endif

template<class tipoelem>
typename listac<tipoelem>::nodo *listac<tipoelem>::inizializza()
{
   if(!inizializzata)
   {
      spazio = new nodo[LUNGVET];
      spazio[0].precedente = LUNGVET - 1;
      spazio[0].successivo = 1;
      lunglistalibera++;
      for(int i = 1; i < LUNGVET; i++)
      {
         spazio[i].precedente = (i - 1) % LUNGVET;
         spazio[i].successivo = (i + 1) % LUNGVET;
         lunglistalibera++;
      }
      inizializzata = true;
      return spazio;
   }
}

template<class tipoelem>
void listac<tipoelem>::sposta(typename listac<tipoelem>::posizione posh, typename listac<tipoelem>::posizione posk)
{
   posizione temp = spazio[posh].successivo;
   spazio[spazio[posh].precedente].successivo = spazio[posh].successivo;
   spazio[spazio[posh].successivo].precedente = spazio[posh].precedente;
   spazio[posh].precedente = spazio[posk].precedente;
   spazio[spazio[posk].precedente].successivo = posh;
   spazio[posh].successivo = posk;
   spazio[posk].precedente = posh;
   posk = posh;
   posh = temp;
}

template<class tipoelem>
typename listac<tipoelem>::nodo *listac<tipoelem>::spazio = listac<tipoelem>::inizializza();

template<class tipoelem>
typename listac<tipoelem>::posizione listac<tipoelem>::listalibera = 0;

template<class tipoelem>
int listac<tipoelem>::lunglistalibera = 0;

template<class tipoelem>
bool listac<tipoelem>::inizializzata = false;

template<class tipoelem>
listac<tipoelem>::listac()
{
   crealista();
}

template<class tipoelem>
void listac<tipoelem>::crealista()
{
   lista = listalibera;
   lunglista = 0;
   listalibera = spazio[listalibera].successivo;
   lunglistalibera--;
   spazio[listalibera].precedente = spazio[lista].precedente;
   spazio[lista].precedente = lista;
   spazio[lista].successivo = lista;
}

template<class tipoelem>
bool listac<tipoelem>::listavuota()
{
   return(lunglista == 0);
}

template<class tipoelem>
typename listac<tipoelem>::posizione listac<tipoelem>::primolista()
{
   return(lista);
}

template<class tipoelem>
bool listac<tipoelem>::finelista(typename listac<tipoelem>::posizione pos)
{
   if(lunglista != 0)
      return(spazio[pos].successivo == primolista());
   else
      cerr << "lista vuota! operatore non applicabile.\n";
}

template<class tipoelem>
typename listac<tipoelem>::posizione listac<tipoelem>::predlista(typename listac<tipoelem>::posizione pos)
{
   return(spazio[pos].precedente);
}

template<class tipoelem>
typename listac<tipoelem>::posizione listac<tipoelem>::succlista(typename listac<tipoelem>::posizione pos)
{
   return(spazio[pos].successivo);
}

template<class tipoelem>
tipoelem listac<tipoelem>::leggilista(typename listac<tipoelem>::posizione pos)
{
   return(spazio[pos].elemento);
}

template<class tipoelem>
void listac<tipoelem>::scrivilista(typename listac<tipoelem>::posizione pos, tipoelem elem)
{
   spazio[pos].elemento = elem;
}

template<class tipoelem>
void listac<tipoelem>::inslista(typename listac<tipoelem>::posizione pos, tipoelem elem)
{
   if(lunglista != 0)
   {
      if(pos == 0)
         lista = listalibera;
      sposta(listalibera, pos);
      lunglistalibera--;
      spazio[lista].elemento = elem;
      listalibera = spazio[listalibera].successivo;
      lunglista++;
   }
   else
   {
      spazio[lista].elemento = elem;
      lunglista++;
   }
}

template<class tipoelem>
void listac<tipoelem>::canclista(typename listac<tipoelem>::posizione pos)
{
   sposta(pos, listalibera);
   if(pos == lista)
      lista = spazio[lista].successivo;
   listalibera = spazio[listalibera].precedente;
   lunglistalibera++;
   lunglista--;
}

testlistac.cpp

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

using namespace std;

int main()
{
   listac<int> list;
   
   /*cout << list.listavuota() << "\n\n";
   
   cout << list.primolista() << "\n\n";
   
   cout << list.finelista(list.primolista()) << "\n\n";
   
   cout << list.predlista(list.primolista()) << "\n\n";
   
   cout << list.succlista(list.primolista()) << "\n\n";
   
   cout << list.leggilista(list.primolista()) << "\n\n";
   
   list.scrivilista(list.primolista(), 10);
   cout << list.leggilista(list.primolista()) << "\n\n\n";*/
   
   system("pause");
   
   listac<int>::posizione p = list.primolista();
   for(int i = 0; i < 10; i++)
      list.inslista(p, (i * 10));
      
   for(p = list.primolista(); p != list.finelista(p); p = list.succlista(p))
      cout << list.leggilista(p) << "\n";
   
   system("pause");
   return 0;
}

perchè il ciclio va all'infinito solo sul primo elemento della lista???

[pietrol83]

vi prego rispondete!!! ho bisogno di capire dove sbaglio.

[oregon]

Non entro nella complessità del codice ma se il loop non va avanti è evidente che qualcosa non funziona come pensavi in

p = list.succlista(p)

Esegui passo passo e cerca di capire il perché ...

[pietrol83]

ho dato un'occhiata, secondo me il metodo succlista sta fatto bene ma è il metodo inslista che dà problemi però penso sia stato fatto bene anche quello. mah!!! non riesco a capire dove sta il problema.

[oregon]

Guarda ... come ti ho detto, non ho proprio il tempo di rivedere tutto il tuo codice ... però noto che quando chiedi il successivo elemento questo vale sempre 0

E' sicuramente un problema nell'inserimento che, per la verità, mi sembra alquanto contorto ...