Newsgroup: it.comp.lang.c
Titolo: Aiuto per compito

Devo svolgere delle esercitazioni in c per l'università ma sono rimasto
bloccato con la scrittura su file ...
Devo scrivere su file e penso di esserci riuscito, ora devo prendere i dati
dal file conoscendo la struct e ricopiarli creando una lista ordinata...
Sotto ho scritto la funz di lettura dove gli ho passato il puntatore
all'inizio, ma ora devo mettere leggi in ordine rispetto ad un valore, per
esempio nome.
-------------------------------------------------------
void inserisci(struct lista **pt)
{
struct lista *pippo,*aux;
aux=*pt;
pippo=(struct lista *)malloc(sizeof(struct lista));
  printf("\nInserisci Nome : ");
  scanf("%s",pippo->nome);
  printf("\nInserisci Cognome : ");
  scanf("%s", pippo->cognome);
  getch();
if (*pt==NULL) {
      printf("\nPrimo inserimento");
      getch();
      *pt = pippo;
      pippo->coda = NULL;
      pippo->in = NULL;
      ;
      }
else { /*Se non è primo inserimento*/
   while ((strcmp(aux->nome,pippo->nome)<0) && (aux->coda!=NULL))/*Ricerca
del punto di inserimento*/
  {/*scorro il punt aux avanti
  printf("\nNome inserito %s è > di %s",pippo->nome,aux->nome);
  getch(); */
  aux = aux->coda;
  }
if ((strcmp(pippo->nome,aux->nome)>=0))
              { /*inserimento in coda */
              pippo->coda=aux->coda;
              aux->coda=pippo;
              pippo->in=aux;
              }
              else
              {
              pippo->coda=aux;
              pippo->in=aux->in;
              aux->in=pippo;
              aux=aux->in;
              aux=aux->in;
              aux->coda=pippo;
              }
 }/*fine else*/
}/*fine*/
.....................
void carica (struct lista **pt)
{
char nome[8];
FILE *fp;
struct lista *leggi;
printf("\nInserisci nome:");
scanf("%s",nome);
fp=fopen(nome,"rt");
if(fp==NULL)
printf("Esci");
else
{
while(!feof(fp))
{
fread(leggi,sizeof(struct lista),1,fp);
}
fclose(fp);
}
...........
}

              }
Queste ultime tre istruzioni potevano semplicemente riassumersi così:
	pippo->in->coda = pippo;
Comunque, se invece di inserire in testa o in coda ad aux a seconda
dei casi, inserisci sempre e comunque in mezzo tra aux e aux->coda
(quindi sempre dopo aux) questo ti permette di compattare di
compattare tutta la scrittura di sopra come segue:
	if((pippo->coda = aux->coda) != NULL)
		pippo->coda->in = pippo;
	aux->coda = pippo;
	pippo->in = aux;
Se aux->coda non è NULL (inserimento in mezzo alla lista), quelle sono
esattamente le stesse righe scritte da te sopra.
Se invece aux->coda è NULL, vale la stessa identica cosa, salvo che il
puntatore aux->coda->in non esiste, e perciò non viene aggiornato.
L'ordinamento alfabetico viene rispettato, anche se il primo elemento
omonimo resta al suo posto nella lista e gli altri omonimi vengono
sempre aggiunti in coda ad esso.
Per il resto mi sembra che funzioni tutto bene, salvo per il fatto che
la funzione di lettura da file non chiama alcuna funzione di
inserimento ordinato in lista e si limita a mettere nella stessa
variabile tutti i dati, perdendoli ogni volta che va a leggere l'unità
seguente.
Qual è esattamente il tuo problema?

 	if((pippo->coda = aux->coda) != NULL)
           ^^^^^^^^^^^^^^^^^^^^^^^^^
Idem.
Codice molto "error prone".
Meglio porre tutto su due righe:
pippo->coda = aux->coda;
if (pippo->coda != NULL) ...
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

Codice del tutto illeggibile => codice poco manutenibile.
Dici?...
Boh?... Sarà che sono abituato così, e che i miei insegnanti tendono a
compattare le istruzioni.
Accolgo l'osservazione, visto che hai più esperienza di me, specie dal
momento che non vi è alcun incremento nelle prestazioni.

if((miofile = fopen(IN_FILE, "rt")) == NULL)
In risposta al mio messaggio in cui suggerivo di spezzare in due
l'istruzione composta.
Lo facevi solamente per evidenziare il fatto che la cosa funziona,
oppure ci sono casi in cui compattare le istruzioni è più
comprensibile di altri? E in tal caso, quali sono queste situazioni in
cui "stilisticamente" non è fastidioso compattare?
Come ho letto in molti posti, tra cui il mitico manuale di Pov-Ray,
"Noting is better than learning by doing".
Thanks in advance
Artemio l'astemio

"Noting is better than learning by doing".
Ehm... volevo scrivere "Nothing"... :-)))

 l'istruzione composta.
No, la mia era una correzione al tuo codice e il
tuo codice era gia' in quella forma.


compattare le istruzioni.
Dico.  Le abitudini, quando si programma per lavoro, e'
meglio metterle da parte per adeguarsi al modo in cui il
codice deve essere scritto per essere manutenuto (leggi:
letto, capito e ampliato da altri).
Il C e' un linguaggio che, purtroppo, tende a far credere
che la compattezza sintattica implichi un incremento di
prestazione (vedi, per esempio, quanta gente erroneamente
crede che i++ sia + veloce di i = i+1).
-- 
Andrea Laforgia (
walkie...@libero.it
)
"Usenet is a strange place" [Dennis Ritchie]

crede che i++ sia + veloce di i = i+1
Lo crede perché (suppongo) in un passato neanche troppo remoto doveva
essere così, quando per eseguire un i++ si usava un'istruzione diretta
del processore, mentre per un i = i + 1 magari ne servivano di più.
Inoltre spesso i libri che si leggono, le slide che vengono proiettate
a scuola e le voci (ahime fallaci) che si sentono in giro, citano
simili esempi come metodi per velocizzare l'esecuzione di un
programma.
Sii clemente. ;-) Il mondo non cambia dall'oggi al domani.

Sii clemente. ;-) Il mondo non cambia dall'oggi al domani.
Allora non puo' essere il mondo informatico.


Allora non puo' essere il mondo informatico.
Sei proprio lapidario, lo sai? ;-)
Rilassarti ti farebbe bene IMHO.
Senza volontà di offesa.

Senza volontà di offesa.
Ci mancherebbe.
