Originariamente inviato da MrX87
bhà ho provato anche io un pò...ho letto come funziona la feof...ma non ho capito come mai da quel valore nullo alla fine...magari qualcuno più esperto risponderà...


bhè qua secondo me ci possono essere due filoni di pensiero: il primo è se hai un file con un numero molto elevato di righe inizia a diventare poco efficiente...perchè deve leggere due volte il file.
Inoltre, se utilizzi la funzione che hai detto tu, non è più necessario utilizzare le liste, in quanto conoscendo la dimensione del file con una bella malloc ti allochi il tuo spazio e gestisci il tutto con un vettore di struct, molto più semplice da gestire rispetto ad una lista! ( infatti agli esami della mia università per costringerci ad usare le liste agli esami specificavano che il file andava letto una e una sola volta!).

Il secondo filone di pensiero, potrebbe trovare la mia soluzione non molto corretta in quanto sei costretto a usare delle variabili di appoggio, anche se alla fine, lo spreco di memoria è limitato....

Tra le due preferisco la mia soluzione, anche perchè è quella che mi hanno insegnato all'università e che ho sempre usato....poi ognuno ha il suo stile a programmare...

Spero di essere stato chiaro...se c sono problemi scrivi!
ciao
Forse preferisco la tua soluzione, credo che implementerò quella. Ora se posso...ho un altro piccolo problema nella cancellazione dei nodi. Precisamente nella cancellazione del nodo in testa. Ho provato qualunque metodo di cancellazione della testa ma quando faccio la free non mi cancella nulla.
Ti passo il codice:
Codice PHP:
/*CANCELLAZIONE DI UN NODO*/
void cancella(struct nodo *nodo){
    struct nodo *prec, *temp;    /*Creo il nodo prec che punta al nodo precedente*/
    int canc, trovato;    /*Variabile per il numero di matricola da cancellare e variabile per controllo matricola esistente*/
    trovato = 0;
    
    printf ("Inserisci la Matricola da cancellare:\n");
    scanf ("%d", &canc);
    
    temp = nodo;
    prec = NULL;    /*Prec parte da zero, per iniziare lo scorrimento della lista da zero*/
    
    while(nodo != NULL){    /*Finchè non arrivo all'ultimo nodo*/
        if((nodo-> mat == canc) && (nodo == temp)){    /*Se la matricola del nodo corrente è uguale alla matricola che dobbiamo eliminare ed è in testa*/
            nodo = nodo-> succ;    /*La testa è il nodo successivo alla testa*/
            free(temp);    /*Cancello il nodo temp che è in testa*/
            printf ("\nTesta cancellata\n");
            temp = nodo;    /*La nuova testa è temp, ovvero il nodo successivo alla vecchia testa*/
            trovato = 1;
            
        }
        else{
            if((nodo-> mat == canc) && (nodo != temp)){    
                prec-> succ = nodo-> succ;    /*Colleco il nodo precedente col nodo successivo a quello corrente*/
                free(nodo);     /*Cancello il nodo*/   
                nodo = prec-> succ;    /*Il nodo corrente diventa il successivo al precedente*/
                printf ("\nMatricola cancellata\n");
                trovato = 1;
        
            }
                else{
                    prec = nodo;    
                    nodo = nodo-> succ;    /*Avanzo di nodo*/
                  }
          }
          
      }
      
      
      if (trovato == 0)    /*Se la matricola non è stata trovata*/
          printf ("\nMatricola non trovata\n");
return;
} 
Intanto ti ringrazio infinitamente per l'aiuto che mi hai dato fino ad ora, se riesci a darmi un'occhiata anche a questo problema te ne sarei altrettanto grato.

PS: E' un esercizio per un progetto universitario, con l'obbligo dell'uso delle liste, funziona tutto e sono vicino alla conclusione, l'ultimo bug è proprio questo.