SOMMARIO SU LETTURA E SCRITTURA (I/O) DEGLI STANDARD FILES Con conversione di formato: int scanf (const char *format,... ) /* ritorna il numero di argomenti assegnati con successo altrimenti EOF se fine file o errore */ int printf (const char *format,... ) /* ritorna il numero di caratteri scritti o EOF se errore*/ Carattere per carattere: int getchar(void) /* ritorna il prossimo carattere di input come un unsigned char (convertito ad int), altrimenti EOF */ int putchar(int c) /* scrive c convertito ad unsigned char; ritorna il carattere scritto oppure EOF in caso di errore */ Linea per linea: char *gets(char *line) /* legge la prossima linea di input dentro l'array line rimpiazzando '\n' con '\0'; ritorna line oppure NULL se si determina fine file o errore */ int puts(const char *line) /* scrive i caratteri in line (fino a '\0' escluso) e aggiunge '\n'; ritorna EOF se si determina errore, zero altrimenti */ Unix ha tre standard files associati ad ogni terminale: standard input (per default la tastiera) standard output (per default il video) standard error (per default il video) che possiamo ridefinire così: denominato stdin denominato stdout denominato stderr comando di input (es. a.out) < file input preso da file comando di output (es. a.out) > file output diretto a file comando di output (es. a.out) > > file output appeso al file comando di output (es. a.out) 2 > file error sul file comando di output (es. a.out) & > file output ed error sul file
INPUT/OUTPUT (con conversione di formato) int printf (const char *format,... ); La notazione... indica che il numero dei parametri è variabile. /* ritorna il numero di caratteri scritti o EOF se errore */ /* la stringa format contiene sia caratteri ordinari, che vengono trascritti tali quali sia specifiche di conversione */ /* ogni specifica di conversione inizia con % e finisce con un carattere di conversione: altre opzioni sono: % - amp. prec char_conv amp è: ampiezza minima del campo (riempito di solito da destra, a meno che sia preceduto dal segno - che indica riempimento da sinistra ) prec è: per un int è il min num di cifre di stampa per un float è il num di cifre decimali dopo il. per una stringa di char è il max num di caratteri ( U n *.* al posto di amp. prec assegna ad amp e prec i due prossimi argomenti, che devono essere interi ) Un con conversione viene stampato come ----------------------------------------------------------------------------------------- %d, %i decimale con segno %o ottale senza segno int(32) %x, %X esadecimale senza segno [o char(8)] %u decimale senza segno %c carattere (ultimo byte) %f [-]m.dddddd double (64) %e [-]d.dddddde+xx [o float (32)] %E [-]d.dddddde+xx %g,%g il meglio tra i tre precedenti char * %s tutti i caratteri fino a '\0' void * %p un indirizzo
int scanf (const char *format,... ); ritorna il numero di argomenti assegnati con successo oppure EOF. /* ogni argomento deve essere un pointer */ /* nel format blanks e tabs vengono ignorati; gli altri caratteri (diversi da %) devono invece combaciare perfettamente con i caratteri non white dell'input. I caratteri white sono: blank, tab, newline, carriage return, vertical tab, form feed */ /* ogni specifica di conversione inizia con %, finisce con un carattere di conversione e guida la conversione del prossimo campo di input. Un campo di input inizia con un non-white e si estende fino alla fine dei nonwhite o del numero di caratteri specificati da amp; unica eccezione è la lettura di un carattere. In pratica la lettura dei numeri termina al primo carattere non lecito, la lettura delle stringhe al primo carattere white. Le opzioni sono: % * amp char_conv * per saltare l'assegnazione (ed il campo di input) amp max campo di input Un con conversione deve leggere un ---------------------------------------------------------------------------------------- %d decimale %i intero (dec. o ott. con 0 o int * esadecimale con 0x) %o ottale ( scritto con o senza 0) %x esad. (scritto con o senza 0x) unsigned int* %u intero dec senza segno %c il primo carattere char * %1s il primo carattere non white %s tutti i caratteri del campo float * %e, %f, %g foating point double * %le, %lf, %lg foating point Oss: un double si legge (senza differenza) con lf, le, lg ma si stampa (con differenza) con f, e, g.
SOMMARIO SU LETTURA E SCRITTURA (I/O) DI FILES NON STANDARD Con conversione di formato: int fscanf (File *fp, char *format,... ) /* come scanf, con la differenza che legge dal file fp */ int fprintf (File *fp, char *format,... ) /* come printf, con la differenza che scrive sul file fp */ Carattere per carattere: int getc (File *fp) /* come getchar, con la differenza che legge dal file fp */ int putc (int c, File *fp) /* come putchar, con la differenza che scrive sul file fp */ int ungetc (int c, FILE *fp) /* rimette il carattere c sul file fp e ritorna c, o EOF se errore */ Linea per linea: char *fgets(char *line,int maxline, FILE *fp) /* legge al più maxline-1 caratteri dentro line, terminando prima se incontra '\n'; il carattere '\n' è incluso nell'array che è terminata con '\0' ; ritorna line oppure NULL se incontra end of file o errore */ int fputs(const char *line, FILE *fp) /* scrive line (che non deve includere necessariamente '\n') sul file fp ; ritorna 0 oppure EOF se c'è errore */ Blocco per blocco: size_t fread(void *ptr,size_t size,size_t nobj,file *fp) size_t fwrite(void *ptr,size_t size,size_t nobj,file *fp) Oss. Ad eccezione delle funzioni fscanf() e fprintf(), che hanno fp come primo parametro, le altre lo hanno come ultimo parametro.
Su un file non standard aperto si scrive e si legge in modo simile a come si scrive o si legge sugli standard files. Esempio 1: #include <stdio.h> #include<stdlib.h> main() { char parola[30]; FILE *fp; if ((fp = fopen("nuovo","w")) == NULL) { puts("errore in apertura per scrivere"); ; fprintf(fp,"oggi e' il 4 dicembre\n"); fclose(fp); if ((fp = fopen("nuovo","r")) == NULL) { puts("errore in apertura per leggere"); while (fscanf(fp,"%s", parola)!= EOF) puts(parola); /* qui feof(fp) è diventata vera */ fclose(fp); return 0; Stampa: Oggi e' il 4 dicembre
GESTIONE DI FILES LETTURA E SCRITTURA (I/O) DI FILES NON STANDARD Sappiamo che quando un programma inizia, tre standard files vengono aperti automaticamente: stdin, stdout e stderr. Per poter leggere (o scrivere) un file non standard occorre aprirlo con la funzione FILE *fopen() in questo modo: FILE *fp; fp = fopen ("path_name_del_file", "r"); /* if (fp == NULL) */ La funzione fopen() ritorna NULL in caso di errore, altrimenti apre il file di nome path_name_del_file, lo associa ad un flusso (stream) di caratteri, memorizza in una struct FILE le informazioni su file e flusso e ritorna un pointer ad essa. Con "w" ( risp. "a") si apre il file per scrivere (risp. aggiungere) dati. L a struct FILE è definita in <stdio.h> ed è costituita da molti campi che contengono informazioni quali: nome del file modalità di accesso indicatore di posizione nel file indicatore di eof indicatore di error L ' indicatore di posizione nel file punta al successivo byte da leggere o scrivere: a fronte di operazioni di lettura/scrittura, il sistema operativo modifica l indicatore di posizione. Esso non può essere manipolato direttamente, ma può essere letto e modificato tramite funzioni di libreria. In C il termine file può riferirsi a un file su disco, al monitor, alla tastiera, a una porta, ecc. Mentre i files differiscono tra loro, gli streams sono uguali, cioè sono sequenze di bytes. Lo stream è quindi interfaccia uniforme ai files. Così l'i/o relativo ad un file diventa I/O di bytes di uno stream. Se si cerca di aprire un file inesistente per scrivere o aggiungere dati, il S.O. lo crea e scrive su di esso i dati, mentre se si cerca di aprire un file inesistente per leggerlo fopen ritorna NULL. Buona norma è chiudere un file aperto, se non serve più, con: fclose (fp); Comunque i files aperti vengono automaticamente chiusi quando un programma termina normalmente.
Ci sono due tipi di streams: text stream Un text stream (flusso testuale) è composto da una sequenza di linee, concluse da newline. Sistemi operativi diversi possono memorizzare linee con formati diversi, utilizzando ad esempio caratteri differenti di terminazione linea. (è usato con caratteri ASCII; può non esserci una corrispondenza oneto-one tra stream e ciò che c è nel file poichè qualche character translation può avvenire) binary stream Su un binary stream (flusso binario) il compilatore non effettua alcuna interpretazione dei byte: i bits di un byte sono letti e scritti come un flusso continuo. (è usato quando è fondamentale preservare l esatto contenuto del file; nessun character translation ; c è corrispondenza one-to-one tra stream e file). Di conseguenza ci sono vari modi per aprire un file. Mode r w a Meaning Open a text file for reading Create a text file for writing Append to a text file r+ Open a text file for read/write w+ Create a text file for read/write a+ Append or create a text file for read/write ----------------------------------------------------------- rb Open a binary file for reading wb Open a binary file for writing ab Append to a binary file r+b w+b a+b Open a binary file for read/write Create a binary file for read/write Append a binary file for read/write
Funzioni utili La chiamata feof(fp) ritorna un valore vero se si è raggiunta la fine del file associato con fp altrimenti ritorna 0 (su files binari feof(fp) diventa vera dopo la lettura dell ultimo dato scritto). La chiamata ferror(fp) ritorna un valore vero se durante la gestione del file associato con fp si è verificato un errore, altrimenti ritorna 0. La chiamata clearerr(fp) riporta ai valori di default i campi error ed eof della struct FILE del file associato con fp. La chiamata rewind(fp) posiziona la posizione corrente all inizio del file. Infine la chiamata exit (int) fa terminare l'esecuzione del programma. L'argomento di exit può essere utilizzato dal processo chiamante ed usato per stabilire se la chiamata ha avuto successo oppure no. Di solito 0 sta per "tutto bene" mentre un valore diverso da zero indica "errore". Osservazioni Il file stdio.h contiene quindi: - Le dichiarazioni dei prototipi di tutte le funzioni di I/O - Le macro costanti EOF, stdin, stdout, stderr - La dichiarazione della struct FILE EOF corrisponde al valore restituito da alcune funzioni di I/O in corrispondenza dell identificatore di fine file. La definizione di NULL, per l ANSI C, è invece contenuta nel file stddef.h: #ifndef NULL #define NULL (void *) 0 #endif Le combinazioni di chiavi per indicare end-of-file varia tra i sistemi: UNIX IBM PC MACINTOSH <return> <ctrl > d <ctrl > z <ctrl > d
NUOVE FUNZIONI di I/O (I/O blocco per blocco) (solo per Files Binari) Le seguenti funzioni possono leggere e scrivere qualunque tipo di dato, qualunque sia la sua rappresentazione. I prototipi sono: size_t fwrite(void *buffer, size_t size, size_t num, FILE *fp); size_t fread (void *buffer, size_t size, size_t num, FILE *fp); La funzione fwrite() scrive sul file associato ad fp, un numero num di oggetti, ciascuno lungo size bytes, prendendoli dall area puntata da buffer. Ritorna il numero di oggetti scritti. Questo valore sarà diverso da num solo in caso di errore. La funzione fread() legge dal file associato ad fp, un numero num di oggetti, ciascuno lungo size bytes, e li memorizza nel buffer puntato d a buffer. Ritorna il numero di oggetti letti; se ritorna 0, nessun oggetto è stato letto, cioè la fine del file è stata raggiunta oppure c è stato errore.
Esempio: #include <stdio.h> #include <stdlib.h> int main() { float f = 1, g, h; float a[3] = {2.,3.,4., b[2]; FILE *fp; if ((fp = fopen("nuovo","wb"))==null) { fputs("errore in apertura file",stderr); fwrite(&f, sizeof(float), 1, fp); fwrite(a, sizeof(a), 1, fp); if (ferror(fp)) { puts("errore in scrittura file"); fclose(fp); if ((fp = fopen("nuovo","rb"))==null) { puts("non posso aprire file scritto"); fread(&g, sizeof(float), 1, fp); fread(b, sizeof(b), 1, fp); fread(&h, sizeof(float), 1, fp); if (ferror(fp)) { puts("errore in lettura"); if (feof(fp)) { puts("lettura oltre la fine file"); printf("%f %f %f %f\n",g, b[0],b[1], h); fclose(fp); return 0; E stampa: 1.000000 2.000000 3.000000 4.000000
BUFFERIZZAZIONE Confrontate con la memoria centrale, le unità di memoria di massa sono molto più lente; il tempo richiesto per accedere alle periferiche eccede largamente il tempo impiegato dalla CPU per i calcoli effettivi. È quindi di fondamentale importanza ridurre, mediante tecniche di bufferizzazione, il numero di accessi alla memoria di massa per effettuare operazioni di lettura/scrittura. Un buffer è un area dei memoria in cui i dati sono memorizzati temporaneamente, prima di essere inviati alle unità di I/O o dopo essere ricevuti dalle unità. Tutti i sistemi operativi utilizzano buffer per leggere/scrivere su unità di I/O: l accesso avviene con granularità di blocco, con blocchi di dimensione 512/4096 byte. Le librerie run time del C contengono due forme distinte di bufferizzazione: bufferizzazione a blocchi e bufferizzazione a linee. Nella bufferizzazione a blocchi, il sistema immagazzina i caratteri fino a riempire un blocco, trasferendolo quindi al sistema operativo. Nella bufferizzazione a linee, il sistema immagazzina i caratteri fino a quando incontra un newline (oppure il buffer è pieno), poi invia l intera linea al sistema operativo (così accade per l inserimento da tastiera). Tutti i flussi di I/O a file utilizzano una bufferizzazione a blocchi, mentre i flussi riferiti a terminale sono dipendenti dal sistema operativo, e sono o non bufferizzati o bufferizzati a linee. Sia nel caso di bufferizzazione a linee che a blocchi, è possibile richiedere esplicitamente al sistema operativo di forzare l invio del buffer a destinazione in un momento qualsiasi, per mezzo della funzione fflush().
ACCESSO DIRETTO A FILES Si fa con le funzioni: ftell() e fseek(), usando le costanti seguenti che sono definite in stdio.h: SEEK_SET SEEK_CUR SEEK_END indica inizio del file indica posizione corrente del file indica fine del file. La funzione ftell() ha, come unico argomento, un puntatore ad un file e restituisce la posizione corrente dell indicatore di posizione nel file. La posizione restituita da ftell() si intende relativa all inizio del file..... per flussi binari rappresenta il numero di caratteri dall inizio del file alla posizione corrente;.. per flussi testuali è un valore dipendente dall implementazione, significativo solo se utilizzato come parametro per fseek(). La funzione fseek() sposta l indicatore di posizione del file a un carattere specificato del flusso. Es. /* Se la ricerca di una certa stringa nel file fallisce, l indicatore di posizione nel file viene riportato al valore originale */ cur_pos = ftell(fp); // posizione originale if (search(string) == FAIL) fseek(fp, cur_pos, SEEK_SET); // riporta l indicatore nella posizione originale Il prototipo di fseek() è: int fseek(file *fp, long int offset, int da_dove) dove: fp offset da_dove : puntatore a file : numero di caratteri di spostamento : posizione di partenza da cui calcolare lo spostamento L argomento da_dove può assumere uno dei tre valori SEEK_SET, SEEK_CUR, SEEK_END. La funzione fseek() restituisce zero se la richiesta è corretta, un valore diverso da zero altrimenti.
Es: L istruzione stat = fseek(fp, 10, SEEK_SET); sposta l indicatore di posizione del file dopo 10 caratteri del flusso (sull undicesimo), che sarà il prossimo elemento letto o scritto. Per flussi binari, lo spostamento (offset) può essere un qualsiasi numero intero che non sposti l indicatore al di fuori del file; per flussi testuali, deve essere zero o un valore restituito da ftell(). Es: L istruzione stat = fseek(fp, 1, SEEK_END); non è lecita se fp è aperto in sola lettura, perché sposta l indicatore oltre la fine del file. NOTA (da manuale): tra una operazione di fread ed una di fwrite (o viceversa) occorre effettuare una chiamata di fseek oppure di fflush. Es: /* Determinazione con fseek e ftell del numero di caratteri di un file passato come parametro */ #include <stdio.h> int main(int argc, char *argv[]) { FILE *fp; int n; if (argc < 2) printf("file non specificato\n"); else { if (( fp = fopen (argv[1], "r")) == NULL){ printf("non trovo il file %s\n", argv[1]); /* spostamento puntatore alla fine del file */ fseek(fp, 0, SEEK_END); /* lettura della posizione dell'indicatore */ n = ftell(fp); printf("il file ha %d caratteri\n",n); fclose(fp); return 0;