Pillola: [C/C++] Lavorare con i file a basso livello

[kentaromiura]

Premessa: Essendo un argomento non troppo semplice
e visto che esistono almeno 3 metodi per la gestione
dei file ho pensato di suddividerlo in tre capitoli
distinti secondo questo schema:

Alto Livello
   |
   -libreria <stdio.h>
   |
   -librerie <iostream.h><fstream.h>
Basso Livello
   -SOTTO LINUX

In questo primo capitolo gestiremo i file ad Alto Livello
(Qualsiasi s.o. c e c++) attraverso la libreria standard <stdio.h>
questa libreria contiene in particolare
fopen,fclose,fseek,ftell,fwrite,fread,
fprintf,fscanf,fgetc,fgets,feof
+ operatore sizeof() che andremo ad analizzare uno ad uno.

[kentaromiura]

fopen:
la fopen serve per aprire un file, funziona cosi:

*FILE = fopen("stringa_con_il_nome_del_file",metodo);

dove metodo puo' essere

"w"  =Crea il file(se esiste lo sovrascrive),il puntatore si posiziona all'inizio
     del file, e' possibile solo scrivere nel file, non leggere
"r"  =Apre il file solo in lettura,il puntatore si posiziona all' inizio
"w+" =Crea il file(se esiste lo sovrascrive),il puntatore si posiziona all'inizio
     del file,si puo scrivere e leggere
"r+" =Apre un file in lettura e scrittura,il puntatore si posiziona all' inizio
"a"  =Apre il file in append.
"a+" =Apre il file in append e in lettura.

int fclose(*FILE);

chiude un file aperto mentre

long pos=fteel(*FILE)

restituisce la posizione nel file(in questo caso chiamata pos).
Per posizionare il puntatore a una determinata posizione si usa

int fseek(*FILE,long int offset,int a)

dove offset puo' essere un valore (con segno)rapresentante
i byte di spostamento e dove a deve essere

0 per spostarsi partendo dall' inizio del file
1 per spostarsi partendo dalla posizione corrente
2 per spostarsi partendo dalla fine del file

un valore di offset positivo spostera' il puntatore in avanti
contrariamente si spostera' in indietro.

fread(
    *dove,
    quanti_byte_spostare,
    quante_volte_fare_la_fread, 
    *FILE_DESTINAZIONE
    ); 

fwrite(
    *da_dove,
    quanti_byte_spostare,
    quante_volte_fare_la_fwrite, 
    *FILE_SORGENTE
    );

fwrite() ed fread vengono usate rispettivamente per leggere e per
scrivere n byte in un file. e' utile utilizzare l'operatore sizeof() che restituisce
la dimensione,ad esempio di una struttura,o di un tipo semplice..

esempio: ho la seguente struttura;

struct pippo {
    int a;
    int b;
};

e voglio salvarla in un file,dovrei
-innanzitutto sapere le specifiche del
compilatore per il tipo int
-i bit del sistema operativo (se 16 e' la meta'..)
-poi per una struttura piu' complessa dovrei fare alcuni calcoli..
fortunatamente esiste sizeof(struct pippo) che restituisce la dimensione!
quindi fread/fwrite avranno questa forma:

fread/fwrite(&struttura, quante_volte_la_salvo/copio, sizeof(struct pippo), destinazione/sorgente);

ricordo che e bene usarla anche con i tipi primitivi (es:sizeof(int))
cosi' il codice risultera' piu' portabile..
fprintf ed fscanf funzionano esattamente come la
printf e la scanf normali, solo che come primo parametro vogliono il file.
fprintf(file_destinazione,"stringa da scrivere eventuali valori:%d",eventuale_valore);
fscanf(file_sorgente,"%d%c",&intero,&carattere);

da notare che fprintf(stdout,""); ed fscanf(stdin,"");
sono l'equivalente di printf e scanf.

fgetc,fgets,fputc,fputs funzionano similmente alle getc,gets,putc,puts normali;
int fputc(int c,*FILE);
int fgetc(*FILE);
*char fgets(*char,DIMENSIONE,*File);
int fputs(costant *char,*FILE);
int fgets(,size*FILE);

feof(*FILE);
la feof restituisce VERO,TRUE,1 dopo che viene effettuata la lettura
oltre al file,quindi dopo che una lettura ha dato esito negativo.
ATTENZIONE: in Basic e' il contrario.

[kentaromiura]

FILE APERTI IN MANIERA ERRATA:
se si apre un file con "w" o con "a" e' logico che non si puo'
leggere dal file..il c vi ritorna caratteri strani o NULL.. quindi
potete veder stampato cose del genere
[][][][]
****
soluzione:
controllare il file e aprirlo nella maniera piu' opportuna

MI SCRIVE UN RECORD IN PIU'
se si fa un output all'interno di un ciclo con controllo feof()
feof restituira' VERO solo DOPO aver letto almeno una volta oltre al
file.. questo vuol dire che se stampate una variabile,o una struttura
all'interno di questo ciclo stamperete 2 volte l'ultima.

SOLUZIONE mettere un if feof(*FILE)break; appena dopo la prima lettura
che puo' generare errore.

ESEMPIO:

while( !feof(input) )
{
    fread(&a, sizeof(char), 1, input);
    
    if( feof(input) )
        break;
    
    putchar(a);
};

[kentaromiura]

Molte volte si ha la necessita' di dover salvare,ad esempio un archivio
per poi modificarlo, o aggiungere dati.
se il programma e' al primo avvio, il record non esistera' e si dovra' crearlo
occorrera' allora adoperare questo sistema:

FILE *dati;
if((dati=fopen("data.dat","r"))==NULL)dati=fopen("data","w+");
else { fclose(dati);
       dati=fopen("data.dat","r+"); 
     } 

per un motivo,che adesso mi sfugge, non conviene aprirlo direttamente con "r+"
ma fare una prova prima con "r".

[kentaromiura]

il c++ utilizza gli stream e gli oggetti :
la libreria iostream.h
fornisce 2 operatori:>> e <<
rispettivamente per l'input e l'output.

i file vengono gestiti con la classe fstream che ha questi metodi:

open();  per aprire uno stream
close(); per chiuderlo
eof();   per segnalare la fine file
good();  true se non ci sono stati errori
fail();  true se ci sono stati
seekg(); per spostarsi all'interno del file
write(); per scrivere
read();  per leggere

oltre a write e a read si possono usare << e >>.

La prossima volta verra' approfondito questo argomento

[kentaromiura]

mi sono completamente dimenticato di dire che nella stringa
contenente il pathname e il nome del file
le barre '\' di separazione del path vanno messe in questo modo:

se il path e' c:\pippo\prova.c

va' caricato con:

Input=fopen("c:\\pippo\\prova.c");

questo perche' i caratteri di escape in c vengono parsati prima della compilazione nella stringa..(circa, adesso non spiego..)

quindi se il path fosse stato
c:\root\nello ci sarebbero stati dei casini, xke' il compilatore
avrebbe interpretato \r come "ritorno del carrello" e \n come "a capo"

quindi per evitare questo noi mettiamo il carattere di escape della \
che e' \\ !!!

[Alexxio]

io non ho capito perchè non mi funzia questo programma che dovrebbe essere da idioti!

#include <stdio.h>
#include <stdlib.h>

main(){
FILE *filepuntatWRITE=fopen("file.txt","w");
char a[80];
FILE *filepuntatREAD=fopen("file.txt","r"); 
char string[80]="prova file sno gau";
printf("%s","ciao\n");
if (filepuntatWRITE) {
	fprintf(filepuntatWRITE,"%c",string);

}
	else printf("sei scemo\n");
		printf("%s","\ntuttobene\n");
	fclose(filepuntatWRITE);

	printf("Ora ti faccio vedere cosa sta scritto sul file:\n") ;

		if (filepuntatREAD){
			
			while(!feof(filepuntatREAD))  {
			fscanf(filepuntatREAD,"\n%c",&a); 
			if(!feof(filepuntatREAD))
				printf("%c",a);
			}
		}
		else	printf("\nQulcosa non è andato molto bene:****ERRORE");

		printf("\n\n**********FINE******\n\n");
		fclose(filepuntatREAD);
	



return 0;
}

[kentaromiura]

devi fare fflush(filepuntatWRITE);
per svuotare il buffer altrimenti succede che quello che scrivi nel
file rimane nel buffer finche' quest' ultimo e pieno(il buffer
e' un area dati in ram..)
soprattutto sotto Linux dove l' I/O e' bufferizzato di default..
comunque invece di usare 2 puntatori sequenziali usane uno solo in lettura e scrittura..
poi tu usi 2 if "strane"
if (filepuntatWRITE)
ed
if (filepuntatREAD)
siccome NULL non e' detto sia 0, anzi in certi os e' uguale a -1
non funziona la if, devi modificarle rispettivamente in

if (filepuntatWRITE!=NULL)
ed
if (filepuntatREAD!=NULL)

[Alexxio]

devo riuscire a farlo solo col c!
non riesco a fare un prog funzionante che LEGGA il file!!

[PaTeR]

Uso getc

buffer = fgetc(pointer);

Per leggere da un file, però mi legge solo il primo carattere... Io vorrei leggerlo tutto, come posso fare?