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?
codice:
#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!