Newsgroup: it.comp.lang.c++
Titolo: stampare una lista

ciao ragazzi vi mostro la classe lista di sotto in cui manca la procedura di
stampa a video e magari su file!
mi date una mano ad implementarle senza usare template e altre classi ma
solo aggiungendo dei metodi?
sono abbastanza all'inizio con le classi e non ho ancora preso la mano!
poichè devo fare una esame mi date qualche consiglio suggerimento e tutto
cio che mi possa aiutare?
vi ringrazio tutti
Antonio!!!
----------------------------------------------------------------------------
----------------------------------------------------------------------------
-----------
//mialista.h
typedef int E;
struct Record{
      E elem;
      Record* punt;
};
typedef struct Record* L;
class Lista{
      public :
       Lista(){l = 0;}
       ~Lista();
        bool empty()const;
        bool full()const;
        void push(const E e);
        void top(E & e)const;
        void pop(E & e);
        void elimina(const E e){eliminaric(l, e);}
        void inserisce(const E e){inserisceric(l,e);}
        bool inlist(const E  e){return inlistric(l,e);}
     private :
      L l;
      void elimina_in_testa(L & l);
      void inserisceric(L & p, const E e);
      void eliminaric(L & p, const E e);
      bool inlistric(const L p, const E e);
};
----------------------------------------------------------------------------
----------------------------------------------------------------------------
-----------
//mia lista.cpp
#include <iostream.h>
#include <stdlib.h>
#include "mialista.h"
//private
void Lista::elimina_in_testa(L & l){
   L lc = l -> punt;
   delete l;
   l = lc;
}
void Lista::inserisceric(L & p, const E e){
    if((p == 0) || (e < p -> elem))
       push(e);
        else
         inserisceric(p -> punt, e);
}
void Lista::eliminaric(L & p, const E e){
    if(p != 0){
       if(e == p -> elem)
         elimina_in_testa(p);
         else
          eliminaric(p -> punt, e);
    }
}
bool Lista::inlistric(const L  p, const E e){
     if(p == 0)
      return false;
      else{
        if(e == p -> elem)
         return true;
         else
           return inlistric(p -> punt, e);
      }
}
//public
Lista::~Lista(){
   L p, q;
   for(p = l; p!= 0; p = q){
     q = p -> punt;
     delete p;
   }
}
bool Lista::empty()const{
   return l == 0;
}
bool Lista::full()const{
   return false;
}
void Lista::push(const E e){
    L q = new Record;
    q -> elem = e;
    q -> punt = l;
    l = q;
}
void Lista::top(E & e)const{
   if(l != 0)
    e = l -> elem;
    else {
     cout << "Lista vuota per richiest top" << endl;
     exit(1);
    }
}
void Lista::pop(E & e){
   if(l != 0){
     e = l -> elem;
     L p = l;
     l = l -> punt;
     delete p;
   }
    else{
     cout << "Lista vuota per richiesta pop" << endl;
     exit(1);
    }
}
----------------------------------------------------------------------------
----------------------------------------------------------------------------
-----------

 Antonio!!!
Ciao Antonio,
io penso che con questa implementazione tu ti stia complicando la vita.
Io non avrei utilizzato ricorsioni all'interno dei metodi, che sono anche
fra l'altro complicati nel seguire in fase di debug.
Ti suggerisco prima di passare alla stampa di cambiare i metodi in modo da
implementarli in iterativi, a meno che non ti sia stato espressamente
richiesto.
Maurus

diciamo che non è stato espressamente richiesto di implementare una lista
con metodi ricorsivi ma la prof dice che la ricorsione è uno degli argomenti
del progr e vanno fatte esercitazioni anche sulla ricorsione, ma d'altra
parte
funziona anche, il problema è che non riesco a implementare dei metodi che
mi consentano di stampare sia a video che su file e non riesco a trovare
nessun tipo di esempio e mi sto quasi avvilendo perchè riesco a implementare
quasi tutto tranne le procedure di stampa!

 quasi tutto tranne le procedure di stampa!
In tutta franchezza non capisco come sia possibile che dopo aver fatto
inserimento, cancellare, etc.. nella lista tu non riesca a fare la cosa piu'
semplice, stamparla a video!!!
Anche se e' in C guarda l'esempio che ho scritto nel msg
news:avl3g0$b7p$1...@sparta.btinternet.com... ( ancora le liste) su
it.comp.lang.c sulle liste. Non uso classi ed e' certamente una lista un
pochino diversa, ma forse ti aiuta uguale.
Se mi spieghi poi cosa non capisci, e cosa non sai fare, saro' lieto di
aiutarti.
Tommy


Prova a mettere nella tua classe lista questa riga:
friend std::ostream& operator<< (std::ostream& os, const Lista& list);
e poi la implementi fuori dalla classe cosi':
std::ostream& operator<< (std::ostream& os, const Lista& list)
{
   L p;
   for(p = list.l; p != 0; p = p->punt)
   {
      os << "<" << p->elem << ">";
      if(p->punt != 0)
      os << ", ";
   }
   os << std::endl;
   return os;
}
e il main lo fai cosi':
int main()
{
   Lista list;
   for (int i = 0; i < 10 ; i++)
      list.push(i);
   std::cout << list;
   system("PAUSE");
   return 0;
}
Delle raccomandazioni:
includi <iostream> senza acca e davanti ai vari cout, endl, ostream,
mettici sempre il suffisso std::
cosi' usi per bene anche i namesapces.
Inoltre non mettere degli exit() nei tuoi metodi ma ritorna sempre qualche
codice da testare, altrimenti esci dal tuo programma e non si capisce
chiaramente il perche' e non liberi per bene la memoria.
Maurus


Ho dimenticato che volevi stampare la lista anche su file.
L'overload dell'operatore << e' gia' fatta ed anche la sua dichiarazione
friend nella classe Lista, per cui li' sei a posto.
Ora devi includere anche:
#include <fstream>
e nel main aggiungi le righe che ti fanno scrivere sul file out.txt:
   std::ofstream out("out.txt");
   out << list << std::endl << "end!";
Non serve che chiudi out perche' la sua chiusura e' automatica con la
chiamata al distruttore di ofstream, quando il blocco finisce.
Maurus

 espressamente richiesto.
Secondo me puoi tenere tranquillamente la ricorsione, a meno che non
ci siano dei problemi di prestazioni dimostrati dal profiler (e non e`
detto che la versione iterativa sia sempre piu` veloce).
        Mauro