Newsgroup: it.comp.lang.c
Titolo: gestione voli

Sareste cosi' gentili da indicarmi gli errori nel seguente programma di
gestione voli, e le eventuali modifiche da apportarvi;
mi crea il file dativoli.dat ma non riesco a visualizzare il contenuto, nel
caso salvasse qualcosa in modo corretto.
grazie
/*programma per la gestione dei voli*/
#include<stdio.h>
#include<stdlib.h>
#define NMAX_VOLI 100
#define file_dati_voli "dativoli.dat"
typedef int tipo_codice_volo[4];
typedef char tipo_destinazione[25];
typedef struct tipo_orario{ int ora;
                            int minuti;
                          }nuovo_or;
typedef struct tipo_rec_volo {tipo_codice_volo codice;
                              nuovo_or  orario;
                              int posti_liberi;
                              tipo_destinazione dest;
                             }rec_volo;
 typedef struct tipo_tabella_voli{rec_volo elenco_voli;
                                int ultimo;
                                /*indica l'ultimo elemento della tabella*/
                                }tabel[NMAX_VOLI],ptabe;
/*FILE  *f;*/
/*struct tipo_tabella_voli tabella;*/
int s; /*variabile per restituire il carattere scelto nel menu*/
int salvato;
struct tipo_tabella_voli rec_tab,ptab;
/*tipo_codice_volo volo;*/
/*struct tipo_orario nuovo_orario;*/
/*prototipi delle funzioni che useremo*/
void carica_tabella(tabel tab);
void salva_tabella(tabel tab);
int indice(tipo_codice_volo volo,tabel tab);
void aggiungi_volo(tabel tab);
void elimina_volo(tipo_codice_volo volo,tabel tab);
void stampa_tabella(tabel tab);
void stampa_volo(tabel tab, tipo_codice_volo cod);
void aggiorna_posti(tabel tab, tipo_codice_volo volo, int k);
void aggiorna_orario(tabel tab,tipo_codice_volo volo, nuovo_or
nuovo_orario);
int menu();
main()
{
/*inizializzazione della tabella: qualunque cosa ci sia nell'array
tab.elenco_voli, il valore di tab.ultimo fa testo: se
 tabella.ultimo==0 la tabella viene considerata vuota.
 Inoltre il primo volo su cui verra' chiesta l'aggiunta in tabella sara'
inserito
 nella componente tabella.ultimo+1 =1*/
char car;
int k;
char ch;
char scelta;
tabel tabella;
nuovo_or nuovo_orario;
tipo_codice_volo volo;
rec_volo nuovo_volo;
ptab.ultimo=0;
while(1)
{
scelta=menu();
 {
 switch(scelta)
 {
 case 'S': {stampa_tabella(tabella);break; }
 case 'V':{ printf("\nstampa del volo: inserite il codice del volo : ");
             scanf("\n%d",&volo);
             stampa_volo(tabella,volo);break;}
case 'A': { aggiungi_volo(tabella);salvato=0;break;}
case 'E': {printf("eliminazione del volo: inserite il codice del volo: ");
scanf("\n%d",&volo);
            elimina_volo(volo,tabella);
            salvato=0;break;}
case 'R': {salva_tabella(tabella);salvato=1;break; }
case 'L': {carica_tabella(tabella);break; }
case 'P': {printf("\aggiorna numero posti prenotati: inserite codice del
volo : ");
            scanf("\n%d",&volo);
            printf("\nnumero di posti prenotati (negativo se si liberano)
");
            scanf("\n%d",&k);
            aggiorna_posti(tabella,volo,k);
            salvato=0;break;}
case 'O': {printf("\naggiornamento orario di partenza: inserite codice del
volo");
            scanf("%d",&volo);
            printf("\nnuovo orario: ");
            scanf("\n%d%c%d",&nuovo_orario.ora,&ch,&nuovo_orario.minuti);
            aggiorna_orario(tabella,volo,nuovo_orario);
            salvato=0;break; }
case 'F': {if(!salvato) {printf("\nsalvo tutto su  %s  ?(s/n)
",file_dati_voli);
                         scanf("\n%c",&ch);
                    if((ch=='S')||(ch=='s'))
                     salva_tabella(tabella);
                     }
case 'U': exit(0);
}
 }
 }
}
scanf("%c",&car);
/*int salvato;*/
/* valore booleano che gli faremo assumere i valori 0 od 1
per sapere se la tabella che eventualmente fosse stata salvata in memoria
secondaria*/
/* dopo ogni modifica alla tabella questa variabile viene assegnata a 0;
in questo modo si sa che la versione della tabella che fosse stata salvata
precedentemente non e' piu' aggiornata. Questa variabile viene assegnata a 1
solo dopo ogni esecuzione dell'operazione di salvataggio*/
}
int menu()
{
 printf("\n************************************************");
 printf("\noperazioni possibili :\n");
 printf("\nS : stampa l'elenco dei voli");
 printf("\nV : stampa un volo dall'elenco");
 printf("\nA : aggiunge un nuovo volo all'elenco");
 printf("\nE : sopprime un volo");
 printf("\nP : aggiorna il numero di posti");
 printf("\nO : aggiorna l'orario di partenza");
 printf("\nL : carica l'elenco dei voli dal file filedati");
 printf("\nR : registra le modifiche all'elenco voli");
 printf("\nF : fine operazioni");
 printf("\nU : uscita dal programma");
 printf("\n\nimmettere operazione da compiere: ");
 s=toupper(getch());
while((s!='S')&(s!='V')&(s!='A')&(s!='E')&(s!='P')&(s!='O')&(s!='L')&(s!='R'
)&(s!='F')&(s!='U'))
 s=toupper(getch());
 printf("\n%c\n",s);
 return(s);
}
/*funzione di caricamento file da memoria secondaria*/
void carica_tabella(tabel tab)
{
/*rec_volo buffer;*/
FILE *f;
int p;
if((f=fopen(file_dati_voli,"rb"))==NULL)
{fprintf(stderr,"\nImpossibile aprire il file");
 return;
}
p=ptab.ultimo=0;
  while(!feof(f)&&(p<NMAX_VOLI))
  {
   p++;
   if(fread(&tab[p],sizeof(struct tipo_tabella_voli),1,f)!=1);
   {
   if(feof(f)){ fclose(f);break;}
   fprintf(stderr,"Errore di lettura del file\n");
   }
  }
 fclose(f);
}
/*funzione di salvataggio tabella nel file*/
/*memorizza nel file f i record contenuti nell'array della tabella
void salva_tabella(tipo_file_voli f, struct tipo_tabella_voli tab)*/
void salva_tabella(tabel tab)
{
FILE *f;
int h;
if((f=fopen(file_dati_voli,"wb"))==NULL)
{
fprintf(stderr,"impossibile aprire il file\n");
fclose(f);
}else
for(h=1;h<=NMAX_VOLI;h++)
if(fwrite(&tab[h],sizeof(struct tipo_tabella_voli),1,f)!=1)
fprintf(stderr,"errore di scrittura\n");
fclose(f);
}
/*funzione di ricerca*/
int indice(tipo_codice_volo volo,tabel tab)
{
/*restituisce l'indice della tabella che ha codice uguale a volo; se
l'elemento non e' presente nella tabella la funzione restituisce 0*/
int h=NMAX_VOLI; /*indice per la scansione della tabella*/
int trovato=0;
 while((h>0)&&(!trovato))
  {
  if(tab[h].elenco_voli.codice==volo)
  trovato=1; /*volo e'stato trovato*/
  else h=h-1;/*preparazione alla ricerca del prossimo elemento*/
  }
/*N.B. se volo non e' stato trovato, allora h=0, altrimenti h
contiene l'indice dell'elemento dell'array tab.elenco_voli, in
cui c'e' volo*/
return(h);
}
void aggiungi_volo(tabel tab)
{
/*aggiunge un volo nella tabella: se ptab.ultimo <NMAX_VOLI vuol dire
che ci sono ancora elementi liberi nell'array tab.elenco_voli;
*/
char space;
int p;
printf("aggiunta volo .... ptab.ultimo =% d ",ptab.ultimo);
 if(ptab.ultimo==NMAX_VOLI-1)
  {
  printf("tabella piena");
  return;
  }
 else
  {
  p=ptab.ultimo;
  p++; /*indice dove andremo ad aggiungere il nuovo volo*/
  printf("\n------ nuovo volo _____");
  printf("\ninserite il codice volo: ");
  scanf("\n%d",&tab[p].elenco_voli.codice);
  printf("Orario di partenza (ore minuti es. 20 15) :");
scanf("\n%d%c%d",&tab[p].elenco_voli.orario.ora,&space,&tab[p].elenco_voli.o
rario.minuti);
  printf("\ninserite il nų di posti liberi : ");
  scanf("\n%d",&tab[p].elenco_voli.posti_liberi);
  printf("\ndestinazione : ");
  scanf("\n%s",&tab[p].elenco_voli.dest);
  }
  salva_tabella(tab);
 } /*fine aggiungi_volo*/
 void elimina_volo(tipo_codice_volo volo, tabel tab)
 {
 /*elimina il volo di codice volo dalla tabella, semplicemente sostituendolo
 con il volo di indice tab.ultimo. Poi tab.ultimo viene spostato indietro
 di un posto (cioe' l'ex penultimo diventa il nuovo ultimo elemento della
 tabella*/
 int i,k;
 carica_tabella(tab);
 i=indice(volo,tab);
 if(i==0)
  printf("\n%d", volo, "codice volo non trovato");
  else
  {
  /*sposta l'ultima struttura sopra quella da eliminare,
  e decrementa "ultimo"*/
  k=tab[i].ultimo;
  tab[i].elenco_voli=tab[k].elenco_voli;
  tab[i].ultimo--;
  }
 }/*fine funzione elimina_volo*/
 void stampa_tabella(tabel tab)
 {
 int h;
 carica_tabella(tab);
 printf("\nstampa dati sui voli");
 printf("\n****************************");
 for(h=0; h<tab[h].ultimo;h++)
  {
  printf("codice volo: %d",tab[h].elenco_voli.codice);
  printf("\n    Orario di partenza: %3d %3d
",tab[h].elenco_voli.orario.ora,tab[h].elenco_voli.orario.minuti);
  printf("posti liberi: %d",tab[h].elenco_voli.posti_liberi);
  printf("\n      destinazione %s ",tab[h].elenco_voli.dest);
  }
 }/*fine stampa_tabella*/
void stampa_volo(tabel tab, tipo_codice_volo cod)
{
/*cerca il codice di codice cod e lo stampa su video*/
int i;
printf("\nsalvate il file prima di stampare il nuovo_volo\n");
carica_tabella(tab);
i=indice(cod,tab);
if(i==0) /* se il volo non e' nella tabella*/
printf("\n%d",cod," :codice volo non trovato");
else
 {
 printf("codice volo %d ",tab[i].elenco_voli.codice);
 printf("\n    Orario di partenza :  %3d %
3d",tab[i].elenco_voli.orario.ora, tab[i].elenco_voli.orario.minuti);
 printf("posti liberi: %d",tab[i].elenco_voli.posti_liberi);
 printf("\n       destinazione %s ",tab[i].elenco_voli.dest);
 printf("\n****************************");
 }
} /*fine stampa_tabella*/
void aggiorna_posti(tabel tab, tipo_codice_volo volo, int k)
{
int i;
carica_tabella(tab);
i=indice(volo,tab);
if(i==0)
 printf("\n%d ", volo,": codice volo non trovato");
 else
 if(tab[i].elenco_voli.posti_liberi<k)
  printf("\nposti insufficienti sul volo %d", volo);
  else tab[i].elenco_voli.posti_liberi= tab[i].elenco_voli.posti_liberi - k;
} /*fine aggiorna_posti*/
void aggiorna_orario(tabel tab, tipo_codice_volo volo,nuovo_or nuovo_orario)
{
int i;
carica_tabella(tab);
if(i==0)
printf("\n%d ", volo," : codice volo non trovato");
else
tab[i].elenco_voli.orario=nuovo_orario;
} /*fine aggiorna_orario*/

gestione voli, e le eventuali modifiche da apportarvi;
Mi spieghi perche' se non hai avuto voglia di scorrerti 300 righe
di codice, ce le dovremmo sciroppare noi ?  
Quando la finirete di considerare il gruppo di discussione come
un luogo in cui affibbiare ad altri la patata bollente ?
Cerca di trovare da solo che cosa non va nel tuo codice e se hai
problemi particolari postane SOLO una PICCOLA parte.

Ciao!
Secondo me non dovresti postare il tuo codice in attesa che una buona anima
lo corregga. Ammetto che anche a me piacerebbe farlo (e infatti un giorno
mandero un pacco di codice a Laforgia per farmelo correggere ^_^) pero non
si impara piu di tanto, eppoi la gente non puo perdere tempo con te!
Cmq ho dato una okkiata
La prima cosa che mi e' saltata agli okki e' questa
while((s!='S')&(s!='V')&(s!='A')&(s!='E')&(s!='P')&(s!='O')&(s!='L')&(s!='R'
)&(s!='F')&(s!='U'))
dovresti mettere &&!
Per il resto aggiustati tu!
Dome

 ha scritto ..........[CUT]
Quanto mi paghi ?!? Molti di noi lo fanno per lavoro, perche' mai farlo
gratis ?!?
Dai, e' lunghissimio, spero te ne sia reso conto. Per guardarlo bisogna
perderci troppo tempo....
Alex


non e' una polemica, non mandarmi subito a quel paese :-)
ma per come lui ha scritto le condizionii del test l'uso di & o di && e'
equivalente, cioe' produce lo stesso effetto, solo che con & fa un po' di
calcoli in piu', meglio &&.
ciao
donCiccio

Infatti avevo il dubbio di farmi una figuraccia ;)
E vabbe ;)
Dome

 perderci troppo tempo....
hai ragione no comment
ciao
"Alex" <nom...@bow.wow> ha scritto nel messaggio
news:Ifj_6.5267$363.2...@news.infostrada.it...


 fclose(f);
scrivono sempre e comunque (NMAX_VOLI + 1) tab[h] nel file.
A me e' capitato di scrivere la tabella subito dopo aver
aperto il programma (ho premuto 'A'): tab non mi sembra
inizializzata da nessuna parte.
La suddivisione del problema non e' male, il codice non mi
sembra molto corretto (tra l'altro mancano tutta una serie
di controlli, es. sul risultato delle scanf).
 
C:\>iao Angelo.