Home/post/C - Gestione dei File Binari

Andrea Falla

0

01 Apr, 2022

C - Gestione dei File Binari

Tra i tanti tipi di archivi esistenti, sono detti "binari" quei file la cui rappresentazione del contenuto, organizzato per record, si basa pienamente sull'uso di sequenze di byte di 1 e 0 (da qui "binario") e sono perciò non comprensibili dall'uomo, dunque la loro interpretazione viene lasciata al calcolatore.

Tutto ciò di cui abbiamo bisogno nel linguaggio C per farne buon utilizzo è la libreria standard di input e output stdio.h. È bene specificare le poche e semplici funzionalità che tratteremo riguardo la gestione dei file sopracitati: apertura, lettura, scrittura e chiusura, ma non solo.

Fondamentale è la comprensione delle variabili in gioco, tra cui almeno un puntatore di tipo FILE, struttura di cui non è necessario conoscere il contenuto per essere utilizzata, che sarà il nostro descrittore all'interno del file in cui operiamo.

1
FILE *fp;

⁠La funzione che ci permette di aprire il file è fopen, la cui sintassi è:

1
FILE *fopen(char *nomeFile, char *modalita);

⁠Restituisce un indirizzo utilizzabile da un puntatore a FILE che ci dà la possibilità di effettuare ogni tipo di azione sul nostro documento grazie ai parametri che vi passiamo, quali la stringa nomeFile, a cui va sostituito il nome del file in cui vogliamo lavorare, e la stringa modalita, al cui posto va inserita la modalità di apertura tra doppi apici ("): ⁠-rb (read binary): posiziona il puntatore all'inizio del file esistente e abilita la possibilità di lettura. La modalità rb+ permette anche la scrittura; ⁠-wb (write binary): crea un file o sovrascrive il contenuto di uno esistente e abilita la possibilità di scrittura. La modalità wb+ permette anche la lettura; ⁠-ab (append binary): posiziona il puntatore in fondo al file esistente (o ne crea uno) e abilità la possibilità di prosecuzione del contenuto, quindi scrittura. La modalità ab+ permette anche la lettura. ⁠In caso di errori di apertura, per esempio causa inesistenza del file, la fopen restituisce NULL. ⁠N.B. un file aperto in modalità solo lettura, per esempio, perché ci si possa scrivere dentro va chiuso e riaperto in modalità scrittura!!

1
#include <stdio.h>
2

3
void main(){
4
    FILE *fp; //file pointer
5
    fp = fopen("binary","rb+"); //fp punta l'inizio del file "binary" aperto in modalità lettura + scrittura
6
}

⁠La funzione che ci permette di leggere il file è fread, la cui sintassi è:

1
size_t fread(void *s, size_t dimensione, size_t nLetture, FILE *fp);

-(size_t è una variabile numerica grande 64bit / 8Byte); ⁠Restituisce il numero di elementi letti con successo, cosa utilizzabile per un controllo sulla buona riuscita dell'operazione. I parametri necessari sono quattro, che nello specifico sono: ⁠-s - è un puntatore alla variabile in cui vogliamo salvare i valori letti, è perciò necessario passarvi l'indirizzo della suddetta variabile; ⁠-dimensione - è la grandezza in byte di ogni record che leggiamo; ⁠-nLetture - è il numero di elementi che leggiamo di grandezza dimensione; ⁠-fp - è il puntatore al FILE che stiamo leggendo.

1
#include <stdio.h>
2

3
void main(){
4
    char c; //i caratteri sono grandi un solo byte
5
    FILE *fp; //file pointer
6
    fp = fopen("binary","rb"); 
7

8
    fread(&c, 1, 1, fp); //leggo un solo elemento di un byte nel file puntato da fp e lo metto in c
9
}

⁠La funzione che ci permette di scrivere il file è fwrite, la cui sintassi è:

1
size_t fwrite(void *s, size_t dimensione, size_t nScritture, FILE *fp);

-(size_t è una variabile numerica grande 64bit / 8Byte); ⁠Restituisce il numero di elementi scritti con successo, cosa utilizzabile per un controllo sulla buona riuscita dell'operazione. I parametri necessari sono quattro, che nello specifico sono: ⁠-s - è un puntatore alla variabile da cui vogliamo pescare i valori da scrivere, è perciò necessario passarvi l'indirizzo della suddetta variabile; ⁠-dimensione - è la grandezza in byte di ogni record che scriviamo; ⁠-nScritture - è il numero di elementi che scriviamo di grandezza dimensione; ⁠-fp - è il puntatore al FILE in cui stiamo scrivendo.

1
#include <stdio.h>
2

3
void main(){
4
    char c = 'a'; //i caratteri sono grandi un solo byte
5
    FILE *fp; //file pointer
6
    fp = fopen("binary","wb"); 
7

8
    fwrite(&c, 1, 1, fp); //scrivo nel file puntato da fp un solo elemento di un byte che si trova in c
9
}

⁠La funzione che ci permette di chiudere il file è fclose, la cui sintassi è:

1
int fclose(FILE *fp);

Restituisce 0 se il file è stato chiuso con successo e l'unico parametro da inserire è il puntatore a FILE fp. È fondamentale come passaggio per non causare problemi di inaccessibilità al file aperto, nel caso in cui qualche altro processo ne debba disporre.

1
#include <stdio.h>
2

3
void main(){
4
    FILE *fp; //file pointer
5
    fp = fopen("binary","rb");
6
    fclose(fp); //il file è stato chiuso ed è disponibile all'utilizzo da altri processi
7
}

⁠La funzione che ci permette di spostarci liberamente nel file è fseek, la cui sintassi è:

1
int fseek(FILE *fp, long int offset, int posizione);

Restituisce 0 se lo spostamento è stato effettuato con successo. Necessita di tre parametri: ⁠-fp - è il puntatore a FILE in cui ci stiamo spostando ⁠-offset - è il numero di byte di cui ci vogliamo spostare dalla posizione corrente ⁠-posizione - rappresentato da tre costanti, indica la posizione da cui vogliamo spostarci: ⁠0 - inizio del file; ⁠1 - posizione corrente; ⁠2 - fine del file.

1
#include <stdio.h>
2

3
void main(){
4
    FILE *fp; //file pointer
5
    fp = fopen("binary","rb");
6
    fseek(fp, 0, 0); //nel file fp è stato spostato di 0 byte dall'inizio
7
    fclose(fp);
8
}

⁠La funzione che ci dice dove siamo nel file è ftell, la cui sintassi è:

1
long int ftell(FILE *fp)

Restituisce il numero di byte di distanza dall'inizio del file e l'unico parametro che richiede è il puntatore al FILE fp.

1
#include <stdio.h>
2

3
void main(){
4
     int distanza; 
5
     FILE *fp; //file pointer
6
     fp = fopen("binary","rb");
7
     fseek(fp, 16, 0); //nel file fp è stato spostato di 16 byte dall'inizio
8

9
     distanza = ftell(fp); //distanza = 16
10

11
     fclose(fp);
12
}

⁠La funzione che ci permette di capire se siamo alla fine del file è feof, la cui sintassi è:

1
int feof(FILE *fp);

Restituisce 1 se il puntatore ha raggiunto la fine del file, cosa che capisce grazie al flag End-of-File (se alzato), e l'unico parametro che richiede è il puntatore al FILE fp.

1
#include <stdio.h>
2

3
void main(){
4
     int fine; 
5
     FILE *fp; //file pointer
6
     fp = fopen("binary","rb");
7
     fseek(fp, 0, 2); //nel file, fp è stato spostato di 0 byte dalla fine del file
8

9
     fine = feof(fp); //fine = 1
10

11
     fclose(fp);
12
}