Programmazione 1

Accesso File in C

Michele Nappi
mnappi@unisa.it
 Il File: Dichiarazione
• In C è definito un tipo FILE

FILE *infile
FILE *outfile

• Le variabili infile e outfile sono puntatori a file

17/12/20 M. Nappi/LP1 2
 Il File: Accesso
• La dichiarazione di un file non è associata
alla creazione del file
• Utilizzo della funzione fopen
file pointer variable=fopen(file name, mode);
• file name: stringa che specifica il nome del file
• mode: stringa che specifica la modalità di
trasferimento dati
– “r”: lettura (il file deve già esistere)
– “w”: scrittura (viene creato un file di nome file name)
– “a”: appending
17/12/20 M. Nappi/LP1 3
 Il File: Accesso
• Possibili modalità di trasferimento
– “rw”: lettura e scrittura (“r+”)
– “wr”: scrittura e lettura (“w+”)
– “ra”: lettura e appending
– “b”: apertura di file binario
• Lettura e Scrittura sullo stesso File (o viceversa)
– fflush(FILE *fp)
• Svuota il buffer
– fseek(FILE *fp, long offset, int place)
• La posizione è offset byte da place
– rewind(FILE *fp)
• La posizione è all’inizio del File (void fseek(fp,0L,Seek_Set))

17/12/20 M. Nappi/LP1 4
 Il File: Chiusura
• I file aperti in C devono essere chiusi al
termine dell’esecuzione

– fclose(infile)
– fclose(outfile)

17/12/20 M. Nappi/LP1 5
 Il File: Scrittura e Lettura
• getc(pointer to file)
• putc(char,pointer to file)

• fscanf(pointer,……….)
• fprintf(pointer,………..)

17/12/20 M. Nappi/LP1 6
Esempio: Scrivere un programma in C che presi in input due file, denominati fileuno e filedue
contenenti caratteri minuscoli, copi il contenuto di filedue in coda a fileuno, e successivamente crei un
nuovo file, il cui nome è inserito dall’utente, in cui sia copiato il contenuto di fileuno invertendo le
minuscole con le maiuscole.

#include <stdio.h> int main(int argc, char *argv[])

{
FILE *uno, *due;
/*definizione prototipi*/
controllo_input(argc);
uno=fopen(argv[1],"a");
controllo_file(uno,argv[1]);
int controllo_input(int); due=fopen(argv[2],"r");
void controllo_file(FILE *, char *); controllo_file(due,argv[2]);
int append_file(FILE *, FILE *); if(append_file(uno,due))
int converti_maiuscole(char *); printf("La scrittura è OK\n");
else
printf("La scrittura non è
avvenuta\n");
if(converti_maiuscole(argv[1])
printf("La conversione è OK\n");
return 0;
}

17/12/20 M. Nappi/LP1 7
 Esempio (continua)
#include <stdio.h>
int controllo_input (int n)
/*definizione prototipi*/
{
if(n!=3)
int controllo_input(int);
{ void controllo_file(FILE *, char *);
printf("Il programma apre due file denominati int append_file(FILE *, FILE *);
fileuno e filedue\n"); int converti_maiuscole(char *);
printf("preceduti dal nome programma: il
risultato sarà la concatenazione\n");
int main(int argc, char *argv[])
printf("dei due file memorizzata in fileuno. {
Successivamente il contenuto\n"); FILE *uno, *due;
printf("di fileuno verrà copiato in un file controllo_input(argc);
nuovo, il cui nome verrà deciso\n"); uno=fopen(argv[1],"a");
controllo_file(uno,argv[1]);
printf("dall'utente, convertendo le minuscole due=fopen(argv[2],"r");
in maiuscole\n"); controllo_file(due,argv[2]);
if(append_file(uno,due))
exit(1); printf("La scrittura è OK\n");
} else
printf("La scrittura non è avvenuta\n");
else if(converti_maiuscole(argv[1])
printf("La conversione è OK\n");
return 0; return 0;
} }

17/12/20 M. Nappi/LP1 8
 Esempio (continua)
void controllo_file(FILE *file, char #include <stdio.h>
*stringa)
/*definizione prototipi*/
{
if(file!=NULL) int controllo_input(int);
void controllo_file(FILE *, char *);
printf("%s è stato aperto int append_file(FILE *, FILE *);
correttamente\n", int converti_maiuscole(char *);

stringa);
else int main(int argc, char *argv[])
{
exit(1); FILE *uno, *due;
} controllo_input(argc);
uno=fopen(argv[1],"a");
controllo_file(uno,argv[1]);
due=fopen(argv[2],"r");
controllo_file(due,argv[2]);
if(append_file(uno,due))
printf("La scrittura è OK\n");
else
printf("La scrittura non è avvenuta\n");
if(converti_maiuscole(argv[1])
printf("La conversione è OK\n");
return 0;
}

17/12/20 M. Nappi/LP1 9
 Esempio (continua)
#include <stdio.h>
int append_file(FILE *f1, FILE *f2)
/*definizione prototipi*/

{ int controllo_input(int);
int c; void controllo_file(FILE *, char *);
while((c=getc(f2))!=EOF) int append_file(FILE *, FILE *);
int converti_maiuscole(char *);
putc(c,f1);
fclose(f1);
int main(int argc, char *argv[])
fclose(f2); {
return(1); FILE *uno, *due;

} controllo_input(argc);
uno=fopen(argv[1],"a");
controllo_file(uno,argv[1]);
due=fopen(argv[2],"r");
controllo_file(due,argv[2]);
if(append_file(uno,due))
printf("La scrittura è OK\n");
else
printf("La scrittura non è avvenuta\n");
if(converti_maiuscole(argv[1])
printf("La conversione è OK\n");
return 0;
}

17/12/20 M. Nappi/LP1 10
 Esempio (continua)
#include <stdio.h>
int converti_maiuscole (char *stringa)
{
char nome[10]; int c; /*definizione prototipi*/
FILE *tre, *f1;
printf("Inserisci il nome file\n");
int controllo_input(int);
scanf("%s",nome); void controllo_file(FILE *, char *);
tre=fopen(nome,"wb"); int append_file(FILE *, FILE *);
controllo_file(tre,nome); int converti_maiuscole(char *);
f1=fopen(stringa,"r");
controllo_file(f1,stringa);
while((c=getc(f1))!=EOF) int main(int argc, char *argv[])
if(c!=' ') {
FILE *uno, *due;
putc(c-32,tre);
else controllo_input(argc);
uno=fopen(argv[1],"a");
putc(c,tre); controllo_file(uno,argv[1]);
fclose(tre); due=fopen(argv[2],"r");
controllo_file(due,argv[2]);
fclose(f1); if(append_file(uno,due))
return (1); printf("La scrittura è OK\n");
else
} printf("La scrittura non è avvenuta\n");
if(converti_maiuscole(argv[1])
printf("La conversione è OK\n");
return 0;
}

17/12/20 M. Nappi/LP1 11