La gestione dei file in C è il processo in cui creiamo, apriamo, leggiamo, scriviamo e chiudiamo operazioni su un file. Il linguaggio C fornisce diverse funzioni come fopen(), fwrite(), fread(), fseek(), fprintf(), ecc. per eseguire input, output e molte diverse operazioni sui file C nel nostro programma.
Perché abbiamo bisogno della gestione dei file in C?
Finora le operazioni che utilizzano il programma C vengono eseguite su un prompt/terminale che non è memorizzato da nessuna parte. L'output viene cancellato alla chiusura del programma. Ma nell'industria del software, la maggior parte dei programmi viene scritta per archiviare le informazioni recuperate dal programma. L'uso della gestione dei file è esattamente ciò che la situazione richiede.
Per capire perché la gestione dei file è importante, esaminiamo alcune funzionalità dell'utilizzo dei file:
- Riutilizzabilità: È possibile accedere, aggiornare ed eliminare i dati archiviati nel file ovunque e in qualsiasi momento garantendo un'elevata riusabilità.
- Portabilità: Senza perdere alcun dato, i file possono essere trasferiti a un altro nel sistema informatico. Il rischio di codifica errata è ridotto al minimo con questa funzionalità.
- Efficiente: Per alcuni programmi potrebbe essere necessaria una grande quantità di input. La gestione dei file ti consente di accedere facilmente a una parte di un file utilizzando poche istruzioni, risparmiando molto tempo e riducendo la possibilità di errori.
- Capacità di memoria: I file consentono di archiviare una grande quantità di dati senza doversi preoccupare di archiviare tutto contemporaneamente in un programma.
Tipi di file in C
Un file può essere classificato in due tipi in base al modo in cui memorizza i dati. Sono i seguenti:
- File di testo
- File binari
1. File di testo
Un file di testo contiene dati nel file forma di caratteri ASCII ed è generalmente utilizzato per memorizzare un flusso di caratteri.
- Ogni riga in un file di testo termina con un carattere di nuova riga (' ').
- Può essere letto o scritto da qualsiasi editor di testo.
- Generalmente vengono archiviati con .TXT estensione del file.
- I file di testo possono essere utilizzati anche per memorizzare il codice sorgente.
2. File binari
Un file binario contiene dati in forma binaria (cioè 0 e 1) invece dei caratteri ASCII. Contengono dati archiviati in modo simile a come sono archiviati nella memoria principale.
- I file binari possono essere creati solo dall'interno di un programma e il loro contenuto può essere letto solo da un programma.
- Più sicuri in quanto non sono facilmente leggibili.
- Generalmente vengono archiviati con .bidone estensione del file.
Operazioni sui file C
Le operazioni sui file C si riferiscono alle diverse operazioni possibili che possiamo eseguire su un file in C come:
- Creazione di un nuovo file – fopen() con attributi come a o a+ oppure w o w+
- Apertura di un file esistente – fopen()
- Lettura da file – fscanf() o fgets()
- Scrittura su un file – fprintf() o fputs()
- Spostamento in una posizione specifica in un file – ricerca() , riavvolgi()
- Chiusura di un file – fclose()
Il testo evidenziato menziona la funzione C utilizzata per eseguire le operazioni sui file.
Funzioni per operazioni su file C
Puntatore di file in C
Un puntatore di file è un riferimento a una posizione particolare nel file aperto. Viene utilizzato nella gestione dei file per eseguire tutte le operazioni sui file come lettura, scrittura, chiusura, ecc. Usiamo il file FILE macro per dichiarare la variabile del puntatore del file. All'interno è definita la macro FILE file di intestazione.
Sintassi del puntatore di file
FILE* pointer_name ;>
File Pointer viene utilizzato in quasi tutte le operazioni sui file in C.
Apri un file in C
Per aprire un file in C, il file fopen() viene utilizzata con il nome file o il percorso del file insieme alle modalità di accesso richieste.
Sintassi di fopen()
FILE* fopen (const char * file_name , const char * access_mode );>
Parametri
- nome del file : nome del file quando presente nella stessa directory del file sorgente. Altrimenti percorso completo.
- modalità_accesso: Specifica per quale operazione verrà aperto il file.
Valore di ritorno
- Se il file viene aperto correttamente, restituisce un puntatore al file.
- Se il file non è aperto, restituisce NULL.
Modalità di apertura dei file in C
Le modalità di apertura dei file o le modalità di accesso specificano le operazioni consentite sul file da aprire. Vengono passati come argomento alla funzione fopen(). Alcune delle modalità di accesso ai file comunemente utilizzate sono elencate di seguito:
| Modalità di apertura | Descrizione |
|---|---|
| R | Cerca il file. Se il file viene aperto con successo fopen() lo carica in memoria e imposta un puntatore che punta al primo carattere in esso contenuto. Se il file non può essere aperto fopen() restituisce NULL. |
| RB | Aperto per la lettura in modalità binaria. Se il file non esiste, fopen() restituisce NULL. |
| In | Aperto per scrivere in modalità testo. Se il file esiste, il suo contenuto viene sovrascritto. Se il file non esiste, viene creato un nuovo file. Restituisce NULL se non è possibile aprire il file. |
| wb | Aperto per la scrittura in modalità binaria. Se il file esiste, il suo contenuto viene sovrascritto. Se il file non esiste, verrà creato. |
| UN | Cerca il file. Se il file viene aperto con successo fopen() lo carica in memoria e imposta un puntatore che punta all'ultimo carattere in esso contenuto. Si apre solo in modalità di aggiunta. Se il file non esiste, viene creato un nuovo file. Restituisce NULL se non è possibile aprire il file. |
| ab | Aperto per l'aggiunta in modalità binaria. I dati vengono aggiunti alla fine del file. Se il file non esiste, verrà creato. |
| r+ | Cerca il file. Viene aperto con successo fopen() lo carica in memoria e imposta un puntatore che punta al primo carattere in esso contenuto. Restituisce NULL se non è possibile aprire il file. |
| RB+ | Aperto sia in lettura che in scrittura in modalità binaria. Se il file non esiste, fopen() restituisce NULL. |
| w+ | Cerca il file. Se il file esiste, il suo contenuto viene sovrascritto. Se il file non esiste, viene creato un nuovo file. Restituisce NULL se non è possibile aprire il file. |
| wb+ | Aperto sia in lettura che in scrittura in modalità binaria. Se il file esiste, il suo contenuto viene sovrascritto. Se il file non esiste, verrà creato. |
| a+ | Cerca il file. Se il file viene aperto con successo fopen() lo carica in memoria e imposta un puntatore che punta all'ultimo carattere in esso contenuto. Apre il file sia in modalità lettura che in modalità aggiunta. Se il file non esiste, viene creato un nuovo file. Restituisce NULL se non è possibile aprire il file. |
| ab+ | Aperto sia per la lettura che per l'aggiunta in modalità binaria. Se il file non esiste, verrà creato. |
Come detto sopra, se vuoi eseguire operazioni su un file binario, devi aggiungere 'b' per ultimo. Ad esempio, invece di w, devi usare wb, invece di a+ devi usare a+b.
Esempio di apertura di un file
C
// C Program to illustrate file opening> #include> #include> int> main()> {> >// file pointer variable to store the value returned by> >// fopen> >FILE>* fptr;> >// opening the file in read mode> >fptr =>fopen>(>'filename.txt'>,>'r'>);> >// checking if the file is opened successfully> >if> (fptr == NULL) {> >printf>(>'The file is not opened. The program will '> >'now exit.'>);> >exit>(0);> >}> >return> 0;> }> |
>
>Produzione
The file is not opened. The program will now exit.>
Il file non viene aperto perché non esiste nella directory di origine. Ma la funzione fopen() è anche in grado di creare un file se non esiste. È mostrato di seguito
Creare un file in C
La funzione fopen() non solo può aprire un file ma può anche creare un file se non esiste già. Per questo dobbiamo utilizzare le modalità che consentono la creazione di un file se non viene trovato come w, w+, wb, wb+, a, a+, ab e ab+.
FILE *fptr; fptr = fopen (' filename.txt ', ' w ');> Esempio di apertura di un file
C
// C Program to create a file> #include> #include> int> main()> {> >// file pointer> >FILE>* fptr;> >// creating file using fopen() access mode 'w'> >fptr =>fopen>(>'file.txt'>,>'w'>);> >// checking if the file is created> >if> (fptr == NULL) {> >printf>(>'The file is not opened. The program will '> >'exit now'>);> >exit>(0);> >}> >else> {> >printf>(>'The file is created Successfully.'>);> >}> > >return> 0;> }> |
>
>Produzione
The file is created Successfully.>
Lettura da un file
L'operazione di lettura del file in C può essere eseguita utilizzando le funzioni fscanf() o fgets(). Entrambe le funzioni eseguono le stesse operazioni di scanf e goes ma con un parametro aggiuntivo, il puntatore al file. Ci sono anche altre funzioni che possiamo usare per leggere da un file. Tali funzioni sono elencate di seguito:
| Funzione | Descrizione |
|---|---|
| fscanf() | Utilizza stringhe formattate e elenchi di argomenti variabili per ricevere input da un file. |
| fget() | Inserisci l'intera riga dal file. |
| fgetc() | Legge un singolo carattere dal file. |
| Ottenere() | Legge un numero da un file. |
| paura() | Legge i byte di dati specificati da un file binario. |
Quindi dipende da te se vuoi leggere il file riga per riga o carattere per carattere.
Esempio:
FILE * fptr; fptr = fopen(fileName.txt, r); fscanf(fptr, '%s %s %s %d', str1, str2, str3, &year); char c = fgetc(fptr);>
getc() e alcune altre funzioni di lettura dei file restituiscono EOF (End Of File) quando raggiungono la fine del file durante la lettura. EOF indica la fine del file e il suo valore è definito dall'implementazione.
c booleano
Nota: Una cosa da notare qui è che dopo aver letto una parte particolare del file, il puntatore del file verrà automaticamente spostato alla fine dell'ultimo carattere letto.
Scrivi su un file
Le operazioni di scrittura sui file possono essere eseguite dalle funzioni fprintf() e fputs() con somiglianze con le operazioni di lettura. La programmazione C fornisce anche alcune altre funzioni che possono essere utilizzate per scrivere dati in un file come:
| Funzione | Descrizione |
|---|---|
| fprintf() | Simile a printf(), questa funzione utilizza stringhe formattate e elenchi di argomenti variabili per stampare l'output nel file. |
| fputs() | Stampa l'intera riga nel file e un ritorno a capo alla fine. |
| fputc() | Stampa un singolo carattere nel file. |
| fputw() | Stampa un numero nel file. |
| fscrivi() | Questa funzione scrive la quantità specificata di byte nel file binario. |
Esempio:
FILE *fptr ; fptr = fopen(fileName.txt, w); fprintf(fptr, '%s %s %s %d', 'We', 'are', 'in', 2012); fputc('a', fptr);> Chiusura di un file
La funzione fclose() viene utilizzata per chiudere il file. Dopo aver eseguito con successo le operazioni sui file, è sempre necessario chiudere un file per rimuoverlo dalla memoria.
Sintassi di fclose()
fclose ( file_pointer );>
dove il puntatore_file è il puntatore al file aperto.
Esempio:
FILE *fptr ; fptr= fopen(fileName.txt, w); ---------- Some file Operations ------- fclose(fptr);>
Esempi di gestione dei file in C
Esempio 1: Programma per creare un file, scriverci dentro e chiudere il file
C
// C program to Open a File,> // Write in it, And Close the File> #include> #include> int> main()> {> >// Declare the file pointer> >FILE>* filePointer;> >// Get the data to be written in file> >char> dataToBeWritten[50] =>'techcodeview.com-A Computer '> >'Science Portal for Geeks'>;> >// Open the existing file GfgTest.c using fopen()> >// in write mode using 'w' attribute> >filePointer =>fopen>(>'GfgTest.c'>,>'w'>);> >// Check if this filePointer is null> >// which maybe if the file does not exist> >if> (filePointer == NULL) {> >printf>(>'GfgTest.c file failed to open.'>);> >}> >else> {> >printf>(>'The file is now opened.
'>);> >// Write the dataToBeWritten into the file> >if> (>strlen>(dataToBeWritten)>0) {> >// writing in the file using fputs()> >fputs>(dataToBeWritten, filePointer);> >fputs>(>'
'>, filePointer);> >}> >// Closing the file using fclose()> >fclose>(filePointer);> >printf>(>'Data successfully written in file '> >'GfgTest.c
'>);> >printf>(>'The file is now closed.'>);> >}> > >return> 0;> }> |
>
>Produzione
The file is now opened. Data successfully written in file GfgTest.c The file is now closed.>
Questo programma creerà un file denominato GfgTest.c nella stessa directory del file sorgente che conterrà il seguente testo: techcodeview.com-A Computer Science Portal for Geeks.
Esempio 2: Programma per aprire un file, leggerlo e chiuderlo
C
// C program to Open a File,> // Read from it, And Close the File> #include> #include> int> main()> {> >// Declare the file pointer> >FILE>* filePointer;> >// Declare the variable for the data to be read from> >// file> >char> dataToBeRead[50];> >// Open the existing file GfgTest.c using fopen()> >// in read mode using 'r' attribute> >filePointer =>fopen>(>'GfgTest.c'>,>'r'>);> >// Check if this filePointer is null> >// which maybe if the file does not exist> >if> (filePointer == NULL) {> >printf>(>'GfgTest.c file failed to open.'>);> >}> >else> {> >printf>(>'The file is now opened.
'>);> >// Read the dataToBeRead from the file> >// using fgets() method> >while> (>fgets>(dataToBeRead, 50, filePointer)> >!= NULL) {> >// Print the dataToBeRead> >printf>(>'%s'>, dataToBeRead);> >}> >// Closing the file using fclose()> >fclose>(filePointer);> >printf>(> >'Data successfully read from file GfgTest.c
'>);> >printf>(>'The file is now closed.'>);> >}> >return> 0;> }> |
>
>
Produzione
The file is now opened. techcodeview.com-A Computer Science Portal for Geeks Data successfully read from file GfgTest.c The file is now closed.>
Questo programma legge il testo dal file denominato GfgTest.c che abbiamo creato nell'esempio precedente e lo stampa nella console.
Leggere e scrivere in un file binario
Finora abbiamo discusso solo delle operazioni sui file di testo. Le operazioni su un file binario sono simili alle operazioni sui file di testo con poche differenze.
Apertura di un file binario
Per aprire un file in modalità binaria, utilizziamo la modalità di accesso rb, rb+, ab, ab+, wb e wb+ nella funzione fopen(). Usiamo anche l'estensione file .bin nel nome file binario.
Esempio
fptr = fopen('filename.bin', 'rb');> Scrivi su un file binario
Usiamo la funzione fwrite() per scrivere i dati in un file binario. I dati vengono scritti nel file binario in un formato di bit (0 e 1).
Sintassi di fwrite()
size_t fwrite (const void * ptr , size_t size , size_t nmemb , FILE * file_pointer );>
parametri:
- ptr: puntatore al blocco di memoria da scrivere.
- misurare: dimensione di ciascun elemento da scrivere (in byte).
- nome: numero di elementi.
- puntatore_file : puntatore FILE al flusso di file di output.
Valore di ritorno:
- Numero di oggetti scritti.
Esempio: Programma per scrivere su un file binario usando fwrite()
C
// C program to write to a Binary file using fwrite()> #include> #include> struct> threeNum {> >int> n1, n2, n3;> };> int> main()> {> >int> n;> >// Structure variable declared here.> >struct> threeNum num;> >FILE>* fptr;> >if> ((fptr =>fopen>(>'C:program.bin'>,>'wb'>)) == NULL) {> >printf>(>'Error! opening file'>);> >// If file pointer will return NULL> >// Program will exit.> >exit>(1);> >}> >int> flag = 0;> >// else it will return a pointer to the file.> >for> (n = 1; n <5; ++n) {> >num.n1 = n;> >num.n2 = 5 * n;> >num.n3 = 5 * n + 1;> >flag =>fwrite>(&num,>sizeof>(>struct> threeNum), 1,> >fptr);> >}> >// checking if the data is written> >if> (!flag) {> >printf>(>'Write Operation Failure'>);> >}> >else> {> >printf>(>'Write Operation Successful'>);> >}> >fclose>(fptr);> > >return> 0;> }> |
>
>Produzione
Write Operation Successful>
Lettura da file binario
La funzione fread() può essere utilizzata per leggere i dati da un file binario in C. I dati vengono letti dal file nella stessa forma in cui sono memorizzati, ovvero in forma binaria.
Sintassi di fread()
size_t fread (void * ptr , size_t size , size_t nmemb , FILE * file_pointer );>
parametri:
- ptr: puntatore al blocco di memoria da leggere.
- misurare: la dimensione di ciascun elemento da leggere (in byte).
- nome: numero di elementi.
- puntatore_file : puntatore FILE al flusso del file di input.
Valore di ritorno:
- Numero di oggetti scritti.
Esempio: Programma per leggere da un file binario usando fread()
C
// C Program to Read from a binary file using fread()> #include> #include> struct> threeNum {> >int> n1, n2, n3;> };> int> main()> {> >int> n;> >struct> threeNum num;> >FILE>* fptr;> >if> ((fptr =>fopen>(>'C:program.bin'>,>'rb'>)) == NULL) {> >printf>(>'Error! opening file'>);> >// If file pointer will return NULL> >// Program will exit.> >exit>(1);> >}> >// else it will return a pointer to the file.> >for> (n = 1; n <5; ++n) {> >fread>(&num,>sizeof>(>struct> threeNum), 1, fptr);> >printf>(>'n1: %d n2: %d n3: %d
'>, num.n1, num.n2,> >num.n3);> >}> >fclose>(fptr);> >return> 0;> }> |
>
>
Produzione
n1: 1 n2: 5 n3: 6 n1: 2 n2: 10 n3: 11 n1: 3 n2: 15 n3: 16 n1: 4 n2: 20 n3: 21>
fseek() in C
Se abbiamo più record all'interno di un file e dobbiamo accedere a un particolare record che si trova in una posizione specifica, dobbiamo scorrere tutti i record prima di ottenere il record. In questo modo si sprecherà molta memoria e tempo operativo. Per ridurre il consumo di memoria e il tempo operativo possiamo utilizzare ricerca() che fornisce un modo più semplice per ottenere i dati richiesti. La funzione fseek() in C cerca il cursore sul record specificato nel file.
Sintassi per fseek()
int fseek(FILE *ptr, long int offset, int pos);>
Esempio di fseek()
C
// C Program to demonstrate the use of fseek() in C> #include> int> main()> {> >FILE>* fp;> >fp =>fopen>(>'test.txt'>,>'r'>);> >// Moving pointer to end> >fseek>(fp, 0, SEEK_END);> >// Printing position of pointer> >printf>(>'%ld'>,>ftell>(fp));> >return> 0;> }> |
>
>
jpa vs ibernazione
Produzione
81>
riavvolgi() in C
IL riavvolgi() la funzione viene utilizzata per portare il puntatore del file all'inizio del file. Può essere utilizzato al posto di fseek() quando si desidera che il puntatore al file si trovi all'inizio.
Sintassi di riavvolgimento()
rewind ( file_pointer );>
Esempio
C
// C program to illustrate the use of rewind> #include> int> main()> {> >FILE>* fptr;> >fptr =>fopen>(>'file.txt'>,>'w+'>);> >fprintf>(fptr,>'Geeks for Geeks
'>);> >// using rewind()> >rewind>(fptr);> >// reading from file> >char> buf[50];> >fscanf>(fptr,>'%[^
]s'>, buf);> >printf>(>'%s'>, buf);> >return> 0;> }> |
>
>Produzione
Geeks for Geeks>
Altre funzioni per operazioni su file C
La tabella seguente elenca alcune altre funzioni che possono essere utilizzate per eseguire operazioni sui file o assistere nell'esecuzione delle stesse.
| Funzioni | Descrizione |
|---|---|
| fopen() | Viene utilizzato per creare un file o per aprire un file. |
| fclose() | Viene utilizzato per chiudere un file. |
| fget() | Viene utilizzato per leggere un file. |
| fprintf() | Viene utilizzato per scrivere blocchi di dati in un file. |
| fscanf() | Viene utilizzato per leggere blocchi di dati da un file. |
| getc() | Viene utilizzato per leggere un singolo carattere in un file. |
| putc() | Viene utilizzato per scrivere un singolo carattere in un file. |
| ricerca() | Viene utilizzato per impostare la posizione del puntatore di un file in una posizione menzionata. |
| dillo() | Viene utilizzato per restituire la posizione corrente del puntatore di un file. |
| riavvolgi() | Viene utilizzato per impostare il puntatore del file all'inizio di un file. |
| putw() | Viene utilizzato per scrivere un numero intero in un file. |
| prendi() | Viene utilizzato per leggere un numero intero da un file. |