Un file di testo contiene record di lunghezza variabile. Ogni byte del file rappresenta il codice ASCII di un carattere. Una riga del file è un record.

Una riga è terminata con un vai a capo che è costituito dalla coppia di caratteri ASCII CR (Carriage Return) e LF (Line Feed), che significano rispettivamente Ritorno Carrello e Avanzamento di una linea.

Il nome attribuito a questi due caratteri deriva dall'uso a cui erano destinati, ovvero quello di comandare una telescrivente. In questo senso il carrello si riferisce alla testina di stampa della telescrivente. La coppia di caratteri aveva lo scopo di riportare il carrello all'inizio della riga di stampa (Carriage Return) e quindi di far avanzare il foglio alla riga successiva (Line Feed), al fine di stampare una nuova riga..

In C un File è una sequenza di byte, quindi durante le operazioni di lettura o di scrittura si deve immaginare che le informazioni vengano acquisite o scritte su un nastro.

La posizione di Lettura/scrittura dell'ipotetica Testina è rappresentata da un puntatore a file. Ad esempio, se si scrive la riga "Testo", verrà registrato un carattere per ogni byte e alla fine verrà accodata la coppia di caratteri CR + LF:

T	e	s	t	o	CR	LF	(vuota)
							↑

Dopo la scrittura il puntatore al file si trova posizionato sul successivo byte del file, da cui si può iniziare a scrivere una nuova riga.

I caratteri CR e LF, che hanno i codici ASCII 13 e 10 rispettivamente, non possono mai comparire all'interno del file. Anche il codice 26 ha un significato speciale, esso indica la fine del file.

Il gestore di archiviazione del sistema operativo riceve tutte le richieste di accesso al file provenienti dai programmi utente.

Il gestore impiega una tabella dei descrittori di file aperti dai processi utente in cui memorizza le informazioni utili per individuare la posizione su disco dei dati di un file.

Inoltre, un file su disco occupa Blocchi di settori (cluster), non necessariamente adiacenti. Il sistema operativo riesce a leggere o scrivere solo un blocco intero, non è in grado di accedere a byte all'interno di un blocco.

Per questo motivo il gestore del sistema di archiviazione effettua le operazioni di lettura e di scrittura in un'area di transito (buffer del disco) in memoria centrale. In fase di scrittura, i caratteri del file vengono registrati nel buffer e solo quando questo si riempie avviene la vera registrazione in un blocco del disco. Analogamente, in fase di lettura, nel buffer viene trasferito un blocco intero e da qui il programma utente ne legge i singoli caratteri. Quando si giunge alla fine del buffer, si procede con la lettura del blocco successivo.

Per creare il puntatore ad un file in C, e per riservare l'area per il buffer di transito, si usa la dichiarazione: dove FILE è una struttura predefinita nella libreria stdio.h. La variabile pf è una locazione di memoria grande quanto basta per mantenere un indirizzo di memoria. La dichiarazione riserva solo lo spazio per pf, per scrivere l'indirizzo del descrittore bisogna prima crearlo con l'istruzione: Il primo parametro della funzione fopen è il nome del file, il secondo parametro è la modalità di accesso in scrittura.

Le modalità di accesso che si possono specificare sono:

• r (read) il file può essere solo letto, inoltre deve esistere.
• w (write) il file viene creato e reso pronto per la scrittura oppure, se esiste, il suo contenuto viene eliminato e si possono scrivere record.
• a (append) il file esiste e i record vengono aggiunti alla fine del file.

Con le modalità w, a, r+, w+ e a+ il file può essere modificato.

Dopo l'apertura bisogna verificare se l'operazione è riuscita. Infatti, se non è stato possibile aprire il file la segnalazione di errore non è automatica, ma è compito del programmatore gestire la situazione anomala. Altrimenti il programma, continuando, non accede al file ma l'utente non se ne accorge. Quindi dopo l'apertura si deve verificare il valore del puntatore:

if (pf==NULL) {
  printf("Errore");
  return;
}

Per scrivere nel file si usa la funzione fprintf: in cui:

• pf è il puntatore al file,
• "%s" è lo specificatore di formato, in questo caso stringa,
• s è il puntatore ad una stringa (un array di caratteri)

Per leggere da un file si usa la funzione fscanf: in cui il significato dei parametri è lo stesso di fprintf

Quando si è terminato di usare il file bisogna chiuderlo. L'operazione di chiusura corrisponde al rilascio dell'area riservata per il buffer e a quella per il descrittore. Le due funzioni: fgets() e fputs() permettono rispettivamente di leggere e scrivere un file una riga alla volta, intendendo come riga una porzione di testo che termina con il codice di fine riga.

La funzione fgets() permette di leggere una riga di testo di una data dimensione massima. Ad esempio: legge una riga di testo di dimensione massima 99 caratteri, dal file rappresentato dal puntatore fp. Questa riga viene trasferita all'interno dell'array s, con l'aggiunta del carattere \0 finale (il 100-mo carattere) di fine stringa.

La funzione fputs() richiede solo la stringa e il puntatore del file da scrivere. Il carattere di fine stringa è già contenuto nella stringa.

Notare che tutte le funzioni di accesso al file richiedono che si specifichi l'indirizzo della locazione di memoria coinvolta nel trasferimento sul file.
Negli esempi precedenti si è usato il nome della stringa che è il puntatore alla stringa, ma nel caso di una variabile semplice bisogna specificare l'indirizzo della variabile, tramite l'operatore &.

Per usare un file di testo si deve dichiarare il puntatore ad una struttura FILE predefinita nella libreria stdio.h:
poi bisogna assegnare il valore al puntatore, aprendo il file:
dove il primo parametro è il nome del file, mentre il secondo parametro (modo) può essere uno dei seguenti valori:

"r"	apre un file in lettura. Il file deve esistere.
"w"	apre in scrittura un file, creandolo se non esiste, ne cancella il contenuto se invece esiste. Il contenuto del file non si può leggere: bisogna chiudere il file e riaprirlo in lettura.
"r+"	apre un file esistente sia per la lettura che per la scrittura,
"w+"	apre un file in scrittura e lettura, creandolo se non esiste.
"a"	Le operazioni di scrittura avvengono alla fine del file. Il file viene creato se non esiste.
"a+"	Il file viene aperto per la lettura, ma il suo contenuto viene protetto dalle operazioni di scrittura, perchè avvengono alla fine del file. Il puntatore al file può essere riposizionato, ad esempio con fseek, solo per leggere, le operazioni di scrittura avverranno sempre alla fine del file. Il file viene creato se non esiste.

Dopo aver aperto il file è opportuno assicurarsi che l'operazione sia riuscita:
Se pf è il puntatore al file,

• per scrivere il valore dell'intero variabile nel file:
  fprintf(pf, "%d", variabile);
• per scrivere una stringa nel file:
  fputs("Stringa", f); (non aggiunge il carattere "vai a capo", quindi per leggerla bisogna specificare il numero di caratteri)
• per scrivere un carattere:
  fputc('X', f);

Lettura:

• per leggere un intero dal file:
  fscanf(f, "%d", &variabile);
• per leggere una stringa il cui puntatore è contenuto nella variabile stringa:
  fgets(stringa, 20, f); (il secondo parametro è il numero massimo di caratteri da leggere, compreso lo zero di fine stringa.
• Per leggere un carattere ch dal file:
  ch = fgetc(f);

Per controllare la presenza di dati da leggere in un file ad accesso sequenziale:

• fgetc restituisce EOF (=true),
• fgets restituisce NULL
• fscanf restituisce EOF (=true).

In tutti i casi, si può controllare la presenza di dati da leggere con la funzione feof, che ritorna true se non ci sono più dati da leggere.:
if (feof(f)) ...
oppure:
while (!feof(f)) ...
Ad esempio per leggere un qualsiasi file di testo, carattere per carattere e mostrarne il contenuto sullo schermo:
FILE *f;
f = fopen("nomefile.txt", "r");
while (!feof(f)) {
    putchar(fgetc(f));
}
fclose(f);

Si suppone che le parole siano delimitate da spazi o da segni di punteggiatura.

Nella stessa cartella in cui si salverà il progetto dev-cpp, creare un file di testo denominato "ContaParole.txt".

Nel documento di testo scrivere un breve brano, Ad esempio:
Nel mezzo del cammin di nostra vita mi ritrovai per una selva oscura che la dritta via era smarrita.
Salvare il file.

Creare un nuovo progetto dev-cpp.
Includere il file header: Nel main, invece, dichiarare le seguenti variabili:

Commenti:

1. pf è il puntatore al file
2. file è un array di caratteri inizializzato con il valore ContaParole.txt
3. Punti è una stringa contenente tutti i caratteri di punteggiatura usati per separare le parole.
4. n è un intero che conta le parole, ch è il carattere letto dal file.

Apertura del file di testo:

Commenti:

5. si apre il file in lettura e si restituisce il puntatore al file.
6. se si verifica un errore la funzione fopen restituisce NULL
7. si segnala un generico errore di apertura (generalmente perchè il file non esiste o la posizione è diversa dalla cartella corrente, o il nome è errato)
8. si esce dal programma con un codice 0, per indicare, ad esempio, l'errore. L'errore viene ricevuto dal sistema operativo che, non avendo istruzioni su come interpretarlo, lo scarta.

Il ciclo di lettura dal file:

Commenti:

10. Si inizia a contare: 0 parole
11. se ci sono caratteri da leggere dal file
12. si legge un carattere dal file, trasferendolo nella variabile ch
13. la funzione strchr(Stringa, carattere) cerca il carattere nella stringa e restituisce la posizione del carattere, se ce n'è più di uno, restituisce la posizione del primo
15. se si tratta di uno dei caratteri di punteggiatura, si ammette che sia terminata una parola e ne inizi un'altra, quindi si conta una parola.
18. Si chiude il file
19. si stampa il numero di parole contate.

Modificando il testo, o prendendo un brano diverso, per collaudare la correttezza del procedimento, si intuisce che, se vengono usati due caratteri di separazione consecutivi, ad esempio una virgola ed uno spazio,il programma conta una parola che non c'è.
Quindi per correggere questo difetto, nella linea 14 si inserisca il seguente ciclo:

Cioè si legge dal file fintanto che ci sono caratteri di punteggiatura consecutivi.

In un file di testo alcuni caratteri sono utilizzati per marcare la fine di una riga (record), la fine del file, ecc.

Quando questa interpretazione di alcuni caratteri non può essere usata, ad esempio perchè si memorizzano numeri, allora il file deve essere usato in modalità binaria (con riferimento alla rappresentazione in binario dei numeri in memoria).
Uno stesso file può essere aperto come file di testo o come file binario, l'uso diverso lo deve gestire il programmatore.

FILE *pfo;
int n=1234;
pfo = fopen("Numeri", "wb");
fwrite(&n, sizeof(n), 1, pfo);
fclose(pfo);

Questo semplice programma apre un file per scrittura in modalità binaria ("wb"), poi usa la funzione
per scrivere su file. La funzione fwrite richiede 4 parametri:

• l'indirizzo della variabile che contiene il valore da scrivere nel file
• la dimensione, in byte, di un elemento,
• il numero di elementi
• il puntatore al file.

La funzione fwrite può scrivere i valori degli elementi di un array:
fwrite(V, sizeof(V[0]), N, pf)
dove V è il puntatore all'array, sizeof(V[0]) è la dimensione in byte del primo elemento, N è il numero di elementi da registrare e pf è il puntatore al file.

Un file scritto in modalità binaria non può essere letto con blocco note, perchè i valori numeri sono codificati in binario ed occupano due soli byte.

Per leggere da file bisogna aprire il file in modalità binaria, e usare l'istruzione fread. FILE *pfi;
int n;
pfi = fopen("Numeri", "rb");
fread(&n, sizeof(n), 1, pfi);
fclose(pfi);

Nota:

Per aprire un file di testo in modalità binaria si deve inserire anche il carattere "b" nella stringa modo (il secondo parametro della funzione fopen). Questo carattere "b" può essere specificato alla fine della stringa ("rb", "wb", "ab", "r+b", "w+b", "a+b") o inserito tra la lettera e il segno "+" ("rb+", "wb+", "ab+").

Premessa
L'esempio seguente viene proposto allo scopo di apprendere le operazioni di accesso ai file. In esso sono presenti alcuni difetti che verranno corretti dopo averne compreso la causa.

Nel programma che si propone si vogliono compiere poche semplici operazioni tipicamente svolte sui file: Inserimento, Lettura, Modifica, Eliminazione record.

Per la scelta dell'operazione si introduce un carattere da tastiera, il programma lo legge e decide quale operazione si richiede. Quindi includere la libreria conio.h per poter usare la funzione getch().

Si dichiari poi il puntatore al file e una stringa contenente il nome del file.

Si supponga di voler registrare nel file un elenco di nomi e numeri di telefono. Definire il formato di un record contenente 2 campi e dichiarare una variabile: Amico


Si definisca una funzione per creare un file il cui nome è specificato nella stringa nomeFile
Dopo la creazione il file viene chiuso. La ragione è dovuta all'eventuale lettura che si potrebbe richiedere dopo la scrittura di record. Questa infatti non potrà avvenire se il file è aperto in scrittura.


La funzione apri() apre il file in lettura/scrittura. Se il file non esiste viene restituito il valore logico false per avvertire il programma chiamante dell'errore.


La funzione Inserisci() riceve l'indirizzo della variabile che contiene i dati e li scrive nel file (dalla posizione corrente)


Nel main si dichiarano due variabili locali e si assegna il valore NULL al puntatore al file.
Poi inizia un ciclo di lettura e di esecuzione dei comandi forniti al programma.
Dopo aver mostrato l'elenco dei comandi, il programma si ferma in attesa che venga premuto un tasto.


Dopo aver scelto il comando, tramite la struttura a diramazione switch si eseguono le azioni corrispondenti.
Si crea, si apre il file ...


Per aggiungere un record si acquisiscono le due stringhe da tastiera (gets) e le si memorizzano nel record allo scopo di trasferirle nel file..


La lettura di tutta la rubrica riposiziona il puntatore al file all'inizio del file (rewind)
Poi avanza di un record alla volta: lo legge e lo stampa.


Infine prima di terminare il programma si chiude il file, se era aperto.

Lanciando il programma in esecuzione, dopo aver creato il file si può inserire qualche valore.
Si inserisca uno o più record. Quando si chiede la lettura di tutta la rubrica si nota che l'ultimo record viene stampato due volte.
L'errore è dovuto al fatto che la segnalazione di end of file viene fornita dopo aver tentato di leggere oltre la fine del file.

Si modifichi il ciclo di lettura:


Si provi adesso a chiudere il programma e a riavviarlo. Prima di leggere tutta la rubrica si scelga l'opzione: "Aggiungi nuovo contatto".

Il nuovo record viene sovrascritto sul primo. Infatti l'operazione di scrittura avviene a partire dalla posizione corrente. Per correggere questo difetto inserire l'istruzione: prima della chiamata della funzione Inserisci.

Inserire altre funzionalità. Ad esempio: la ricerca di un record, la modifica e la cancellazione di un record.

Ricerca.
Inserire l'opzione 5: Cerca un record.
Nella sezione switch inserire l'operazione di ricerca:

Inserire la definizione della funzione cerca:

Affinchè la funzione cerca possa confrontare la stringa cercata con quella letta occorre includere il file header: