FILE: tipo operazione Istruì. prototipo esempi lettura di un carattere

FILE:
tipo operazione
lettura di un carattere
alla volta
Scrittura di un
carattere alla volta
Lettura di una linea
alla volta
Scrittura di una linea
alla volta
Lettura di un record
(lunghezza fissa)
Scrittura di un
record(ll fissa)
Lettura non
strutturata (campo a
campo)
Scrittura non
strutturata
Accesso diretto allo iesimo record
Istruì.
fgetc
prototipo
Int fgetc(FILE *flusso)
fputc
Int fputc(int ch, FILE *flusso);
fgets
Char fgets(char *str, int num, FILE *flusso);
fputs
Int fputs(const char *str, FILE *flusso);
fread
Size_t fread(void *buffer, size_t num_byte, size_t
contatore, FILE *fp)
Size_t fwrite(void *buffer, size_t num_byte, size_t
contatore, FILE *fp)
Int fscanf(FILE *fp, const char * stringa di
controllo, …)
fwrite
fscanf
fprintf
fseek
Apertura del file
fopen
Chiusura del file
Cancellazione del file
Condizione di fine file
fclose
remove
feof
Int fprintf(FILE *fp, const char * stringa di
controllo, …)
Int fseek(FILE *fp, long num_byte, int origine);
Origine : SEEK_SET oppure 0
SEEK_CURR oppure 1
SEEK_END oppure 2
FILE *fopen(const char*fname, const char
*mode);
Int fclose(FILE *flusso)
Int remove(char *nomefile)
Int feof(FILE *fp)
esempi
Vedi sotto
fgets(str,sizeof(….),fp)
vedi sotto
vedere dopo
fp =
fopen(argv[1],”a+”)
… remove(argv[1])…
While (!feof(fp)) …
1) Lettura di un file un carattere alla volta
a)…..
…..
FILE *fpin;
….
int c; /* dichiarato di tipo int per poter testare EOF */
…..
…
while ((c=fgetc(fpin) != EOF)
{
…}
Il valore EOF viene restituito anche nel caso in cui fgetc( ) incontri un errore. Se lavorate con file binari dovete usare la
funzione ferror( ) per controllare un'eventuale condizione di errore nell'accesso al file.
Esempio .
Questo programma legge e mostra sullo schermo il contenuto di un file di tipo testo:
#include "stdio.h"
#include "stdlib.h"
main(int argc, char *argv[l)
{
FILE *fp;
char ch;
if((fp=fopen(argv[1],”r"))==NULL}
{ printf'(“il file non può essere aperto\n");
exit(1);
}
while((ch=fgetc(fp))!=EOF)
{
printf{"%c",ch);
}
fclose(fp);
}
b)
{
FILE *fp;
char ch;
….
ch=fgetc(fp);
while(ch!=EOF)
{
putchar(ch);
ch = fgetc(fp);
}
c)
do {
ch = fgetc(fp);
} while (ch!= EOF);
1b) scrittura di un carattere alla volta.
#include "stdio.h"
int fputc(int ch, FILE *flusso);
La funzione fputc() scrive nel flusso specificato il carattere ch alla posizione corrente del file e poi incrementa l’
indicatore di posizione. Sebbene ch sia dichiarato come intero, la funzione fputc( ) lo converte in un unsìgned char.
Poiché tutti gli argomenti di tipo carattere sono convertiti in interi alla chiamata della funzione, generalmente vengono
usate come argomenti le variabili di tipo carattere. Se viene usalo un intero, viene scartato il byte più significativo.
Il valore restituito da fputc( ) è quello del carattere scritto. Se si verifica un errore, la funzione restituisce EOF. Per i file
dì tipo binario, il carattere EOF può essere considerato valido e bisogna quindi utilizzare la funzione ferror( ) per
determinare un'eventuale condizione di errore.
2) Lettura di un file una linea alla volta
char *fgets(char *buffer, int n,FILE *fpin);
….
#define MAXSTR 81
..
{
char buff[MAXSTR +1];
….
while (fgets(buff, MAXSTR,fpin) != NULL)
{….. }
}
…
La funzione fgets() legge una stringa dal flusso specificato fino alla lettura di un new line o di lung – 1 caratteri.
Eventuali caratteri new line vengono memorizzati nella stringa ( a differenza di gets()) e la stringa risultante viene
terminata da un carattere nullo. La funzione restituisce un puntatore a str o un puntatore nullo nel case di errore .
La funzione fgets legge una linea ( con un massimo di caratteri pari a n meno 1) dal file e pone la linea in buffer. La
linea viene terminata da un \n o da EOF. Alla linea o agli n caratteri contenuti in buffer viene aggiunto un terminatore di
stringa
Esempio
Questo programma usa la funzione fgets( ) per mostrare sullo schermo il contenuto di un file di tipo testo specificato
nella riga di comando.
#include "stdio.h"
#include "stdlib.h"
void main{int argc, char *argv[])
{
FILE *fp;
char str[128];
if({fp=fopen(argv[1],"r”))==NULL)
{
printf("Il file non può essere aperto\n");
exit(1);
}
while((!feof(fp))
{
il (fgets(str,126,fp)) printf{"%s.str);
}
}
fclose(fp);
2b) scrittura di una linea alla volta
«include "stdio.h"
int fputs(const char *str, FILE *flusso);
La funzione fputs( ) scrive il contenuto della stringa puntata da str nel flusso specificato. Il terminatore NULL non
viene scritto.
La funzione fputs( ) restituisce 0 se la chiamata ha successo, altrimenti il valore EOF.
Se il flusso è aperto con modalità di tipo testo, la funzione può effettuare alcune conversioni di caratteri. Ciò significa
che può non esserci una corrispondenza uno a uno tra la stringa e il file. Viceversa, se il file viene aperto in modalità
binaria. non si verifica alcuna traduzione di caratteri e c'è una corrispondenza uno a uno tra la stringa e il file.
Esempio
Questa istruzione scrive la stringa Questa è una prova sul flusso a cui punta fp:
fputs("Questa è una prova",fp);
3) Lettura di un file in parti di dimensioni fissate
size_t fread(void *buffer,size_t num_byte,size_ contatore, FILE *fp);
il valore restituito da fread e’ il numero di elementi letti. Il valore di ritorno sara’’ minore o uguale a numero in caso di
errore o se viene letto il carattere di fine file
4) La funzione FEOF()
prototipo
int feof(FILE *fp)
La funzione feof() consente di verificare la condizione di fine file per una lettura di file binari e di testo
La funzione restituisce il valore vero alla fine del file e zero altrimenti
Esempio
…
while(!feof(fp)){
fgets(str,79,fp);
printf(str);
}
5) la funzione fscanf() e fprintf()
Nel sistema di I/O bufferizzato sono comprese anche fprintf() e fscanf( ), che si comportano esattamente come le
funzioni printf( ) e scanf( ), con l'eccezione che lavorano su file su disco. Il loro prototipo generale è:
ìnt fprintf(FILE *fp, const char *stringa_di_controtlo,...);
ìnt fscanf(FILE *fp, const char *stringa_di_contrltlo,...);
in cui, come sempre, fp è il puntatore restituito dall'apertura con fopen( ). fprìntf( ) e fscanf( ) dirigono le loro
operazioni di I/O sul file a cui punta fp.
#include "stdio.h"
int fscanf(FILE *flusso, const char *format,...);
La funzione fscanf( ) opera esattamente come scanf( ) ma legge l'informazione dal flusso specificato da flusso invece
che da stdin .
La funzione fscanf( ) restituisce il numero di argomenti ai quali è stato effettivamente assegnalo un valore e questo
numero non comprende i campi saltali. Il valore EOF implica una condizione di errore precedente alla prima
assegnazione.
Esempio
Le seguenti istruzioni leggono una stringa e un numero float dal flusso fp:
char str[80];
float f;
fscanf(fp, "%s%f",str, &f);
#include "stdio.h"
int fprintf(FILE *flusso, const char *format,...);
La funzione fprintf () stampa sul flusso specificato i valori degli argomenti compresi nell'elenco degli argomenti come
richiesto nella stringa format. Il valore restituito è il numero di caratteri stampati realmente; se si verifica un errore,
viene restituito un valore negativo.
Le operazioni di stringa di controllo del formato e i comandi sono uguali a quelli delle funzioni printf( )
Esempio
Questo programma crea un file chiamato testo e scrive nel file la stringa Questa è una prova. 10 20.01, usando la
funzione fprintf( ):
#include "stdio.h"
#include "stdlib.h"
void main(void)
{
FILE *fp;
if((fp=fopen("testo","wb"))==NULL}
{
printf("ll file non può essere aperto\n");
exit(1);
}
fprintf(fp, "Questa è una prova %d %f”, 10, 20.01);
fclose(fp);
………
\
L'uso e l'utilità delle due funzioni è mostrato dal seguente esempio, che legge da tastiera una stringa e un intero, li scrìve
in un file su disco, poi li legge dal file e li visualizza sullo schermo.
/• fscanf - fprintf: esempio */
.
# include "stdio.h"
# include "io.h"
#include "stdlib.h"
void main{void)
{
FILE *fp;
char s[80];
int t;
if((fp=fopen("test", "w")) == NULL)
{ printf("Errore nell'apertura del file\n");
exit(1);
}
printf("Inserisci una stringa e un numero: ");
fscanf(stdin, "%s%d", s, &t); /* legge dalla tastiera */
fprintf(fp, "%s %d", s, t); /* scrive nel file */
fclose(fp);
if((fp=fopen(“ ”test","r")) == NULL)
{ printf("Errore nell'apertura del file”);
exit(1);
}
fscanf(fp, "%s%d", s, &t); /* legge dal (ile */
fprintf(stdout, "%s %d", s. t); /* visualizza sullo schermo */
}
fclose(fp);
}
NOTA BENE: questo esempio scrive e legge un solo record
OVVIAMENTE invece di usare fscanf per standard input si poteva usare scanf e invece di fprintf su standard output si
poteva usare printf
NOTA bene!!!!!!!! Fprintf e fscanf permettono di scrivere e leggere facilmente su file dati disomogenei ma non
sono le istruzioni più efficienti. Infatti i dati sono in formato ASCII e non binari. Qualora siano richieste
particolari esigente di velocità ed efficienza meglio ricorrere a fread() e ferite()
GLI ARGOMENTI PRESENTI SULLA LINEA DI COMANDO
UNIX>nome_eseguibile nome_file_1 nome_file_2
(sulle linea comandi in questo esempio sono stati digitati tre parametri)
… nel programmma C:
void main(int argc, char *argv[ ])
argc contiene il numero di parametri presenti sulla linea di comando (3 nel nostro caso)
argv[ ] e’ chiamato vettore degli argomenti ed e’ un array di puntatori a char
esempio di utilizzo
….
FILE *fpin, *fpout;
void apri_file(int arcg, char *argv[ ]);
…
void main (int argc, char *argv[ ])
{
apri_file(argc,argv);
…
}
void apri_file(int argc, char *argv[ ])
{
if (argc!=3)
{printf(“errore nel numero di parametri\n”;
exit(EXIT_FAILURE);
}
if (fpin=fopen(argv[1],”r”))==NULL)
{ printf(“errore nell’apertura di %s \n”, argv[1];
exit(EXIT_FAILURE)
}
……
}