[C++] Caricare lista "linkata" da file

[rocco.g]

Ciao a tutti!

Vorrei fare una cosa del genere:

Prendere un file di testo ed usarlo come db per le cose che mi viene in mente di scriverci, e poi richiamarlo all'interno di un prog in C++ ordinando le stringhe.

Mi spiego meglio:
usando una lista linkata vorrei scrivere e leggere da un semplice file di testo...
sono partito dall'algoritmo di una lista linkata che usa i template per poter gestire tipi di dati diversi...
Funziona bene se i dati glieli dai da tastiera...
ma io vorrei che lavorasse con il file...

Come posso fare?

utilizzo un ciclo while che legge sino alla fine del file e per ogni stringa che incontra le applica l'algoritmo?
come potrei fare?

#include <string>
#include <iostream>
#include <cassert>

using namespace std;

/* dichiarazioni iniziali */
template<typename T> class List;
template<typename T> class Iterator;

/**
   Una classe contenente i nodi per la lista collegata.
*/
template<typename T>
class Node
{
public:
   /**
      Crea un nodo per un determinato valore di dati.
      @param s i dati da archiviare in questo nodo
   */
   Node(T s);
private:
   T data;
   Node<T>* previous;
   Node<T>* next;
friend class List<T>;
friend class Iterator<T>;
};
   
/**
   Un iteratore denota una posizione nella lista o
   oltre la fine della lista.
*/
template<typename T>
class Iterator
{
public:
   /**
      Crea un iteratore che non è collegato a nessuna lista.
   */
   Iterator();
   /** 
       Cerca il valore in una determinata posizione.
       @return valore del nodo a cui fa riferimento
       l’iteratore
   */
   T operator*() const;
   /**
      Fa avanzare l’iteratore alla posizione successiva.
   */
   void operator++(int dummy);
   /**
      Sposta l’iteratore alla posizione precedente.
   */
   void operator--(int dummy);
   /**Confronta due iteratori.
      @param b iteratore da confrontare con questo iteratore
      @return true se questo iteratore e b non sono uguali
   */
   bool operator==(Iterator<T> b) const;
   /**
      Confronta due iteratori.
      @param b iteratore da confrontare con questo iteratore
      @return true se questo iteratore e b non sono uguali
   */
   bool operator!=(Iterator<T> b) const;
private:
   Node<T>* position;
   Node<T>* last;
friend class List<T>;
};

/**
   Una lista collegata di valori di un determinato tipo.
   @param T tipo di valori della lista
*/
template<typename T>
class List
{
public:
   /**
      Crea una lista vuota.
   */
   List();
   /**
      Crea una lista come copia di un’altra lista.
      @param b lista da copiare
   */
   List(const List<T>& b);
   /**
      Elimina tutti i nodi di questa lista.
   */
   ~List();
   /**
      Assegna un’altra lista a questa lista.
      @param b lista da assegnare
      @return riferimento a questa lista
   */
   List<T>& operator=(const List<T>& b);

   /**
      Aggiunge un elemento alla lista.
      @param s valore da aggiungere
   */
   void push_back(T s);
   /**
      Inserisce un elemento nella lista.
      @param iter posizione prima della quale avviene l’inserimento
      @param s valore da aggiungere
   */
   void insert(Iterator<T> iter, T s);
   /**
      Rimuove un elemento dalla lista.
      @param i la posizione di rimozione
      @return un iteratore riferito all’elemento successivo
      all’elemento cancellato
   */
   Iterator<T> erase(Iterator<T> i);
   /**
      Ottiene la posizione iniziale della lista.
      @return un iteratore riferito all’inizio della lista
   */
   Iterator<T> begin();
   /**
      Ottiene la posizione oltre l’ultimo elemento della lista.
      @return un iteratore riferito al punto oltre la fine della lista
   */
   Iterator<T> end();

private:
   /**
      Copia un’altra lista in questa lista.
      @param b lista da copiare
   */
   void copy(const List<T>& b);
   /**
      Elimina tutti i nodi della lista.
   */
   void free();
   
   Node<T>* first;
   Node<T>* last;
};

template<typename T>
List<T>::List()
{  
   first = NULL;
   last = NULL;
}

template<typename T>
List<T>::~List()
{  
   free();
}

template<typename T>
List<T>::List(const List<T>& b)
{  
   first = NULL;
   last = NULL;
   copy(b);
}

template<typename T>
List<T>& List<T>::operator=(const List<T>& b)
{  
   if (this != &b)
   {
      free();
      copy(b);
   }
   return *this;
}


template<typename T>
void List<T>::push_back(T s)
{  
   Node<T>* newnode = new Node<T>(s);
   if (last == NULL) /* lista vuota */
   {  
      first = newnode;
      last = newnode;
   }
   else
   {  
      newnode->previous = last;
      last->next = newnode;
      last = newnode;
   }
}

template<typename T>
void List<T>::insert(Iterator<T> iter, T s)
{  
   if (iter.position == NULL)
   {  
      push_back(s);
      return;
   }

   Node<T>* after = iter.position;
   Node<T>* before = after->previous;
   Node<T>* newnode = new Node<T>(s);
   newnode->previous = before;
   newnode->next = after;
   after->previous = newnode;
   if (before == NULL) /* inserire all’inizio */
      first = newnode;
   else
      before->next = newnode;
}

template<typename T>
Iterator<T> List<T>::erase(Iterator<T> i)
{  
   Iterator<T> iter = i;
   assert(iter.position != NULL);
   Node<T>* remove = iter.position;
   Node<T>* before = remove->previous;
   Node<T>* after = remove->next;
   if (remove == first)
      first = after;
   else
      before->next = after;
   if (remove == last)
      last = before;
   else
      after->previous = before;
   iter.position = after;
   delete remove;
   return iter;
}

template<typename T>
Iterator<T> List<T>::begin()
{  
   Iterator<T> iter;
   iter.position = first;
   iter.last = last;
   return iter;
}

template<typename T>
Iterator<T> List<T>::end()
{  
   Iterator<T> iter;
   iter.position = NULL;
   iter.last = last;
   return iter;
}

template<typename T>
Iterator<T>::Iterator()
{  
   position = NULL;
   last = NULL;
}

template<typename T>
T Iterator<T>::operator*() const
{  
   assert(position != NULL);
   return position->data;
}

template<typename T>
void Iterator<T>::operator++(int dummy)
{  
   assert(position != NULL);
   position = position->next;
}

template<typename T>
void Iterator<T>::operator--(int dummy)
{  
   if (position == NULL)
      position = last;
   else 
      position = position->previous;
   assert(position != NULL);
}

template<typename T>
bool Iterator<T>::operator==(Iterator<T> b) const
{  
   return position == b.position;
}

template<typename T>
bool Iterator<T>::operator!=(Iterator<T> b) const
{  
   return position != b.position;
}

template<typename T>
Node<T>::Node(T s)
{  
   data = s;
   previous = NULL;
   next = NULL;
}

template<typename T>
void List<T>::copy(const List<T>& b)
{
   for (Iterator<T> p = b.begin(); p != b.end(); p++)
      push_back(*p);
}

template<typename T>
void List<T>::free()
{
   while (begin() != end())
      erase(begin());
}

int main()
{  
   ...
   ...  


  if(argc!=2)
		printf("Devi inserire un file da caricare!\n");
	else{
								
		if(fp = fopen(argv[1],"r") ){
			staff.insert(pos, fp);
                        pos++;
                        fclose(fp);
		}
 
   return 0;
}

ho provato ad aprire il file così... e caricare le stringhe nella lista... ma poi non so come fare... da questo punto in poi... e non so se questa cosa che ho fatto funziona...

mi aiutate perfavore?

Grazie!

[rocco.g]

nessuno che mi possa aiutare?