File in C
APERTURA E CHIUSURA
std::FILE* fopen( const char* filename, const char* mode );
Le modalità di apertura sono elencate nella cartella sottostante
La modalità b indica la modalità binaria per cui viene associata ad r oppure a w per dire che il file viene aperto in modalità lettura o scrittura binaria

Valore di ritorno
In caso di esito positivo, restituisce un puntatore all’oggetto che controlla il flusso di file aperto, eliminando sia l’eof che i bit di errore. Lo stream è completamente bufferizzato a meno che il nome file non si riferisca a un dispositivo interattivo.
In caso di errore, restituisce un puntatore nullo. POSIX richiede che in questo caso sia impostato errno .
/* Prof. Alessandro Barazzuol */ #include<iostream> #include<stdio.h> #include <string> using namespace std; int main() { FILE *f=fopen("file1.txt","r"); if(f==NULL) cout<<"File non aperto \n"; else { cout<<"File aperto con successo\n"; }
int fclose ( std :: FILE * stream ) ;
Valore di ritorno
0 in caso di successo, EOF altrimenti
LETTURA E SCRITTURA DIRETTA BLOCCHI BYTES
std :: size_t fread ( void * buffer, std :: size_t size, std :: size_t count, std :: FILE * stream ) ;
std :: size_t fwrite ( const void * buffer, std :: size_t size, std :: size_t count, std :: FILE * stream ) ;
Legge gli count
oggetti nell’array buffer
dal flusso di input dato stream
come se chiamasse std :: fgetcsize
times per ogni oggetto e memorizzi i risultati, nell’ordine ottenuto, nelle posizioni successive di buffer
, che viene reinterpretata come una matrice di caratteri non firmati . L’indicatore di posizione del file per lo streaming è avanzato dal numero di caratteri letti.
Scrive fino agli count
oggetti binari dall’array specificato buffer
al flusso di output stream
. Gli oggetti sono scritti come se reinterepreting ogni oggetto come una matrice di caratterinon firmati e chiamando std :: fputcsize
volte per ciascun oggetto per scrivere quei caratterinon firmati in stream
, nell’ordine. L’indicatore di posizione del file per lo stream è avanzato dal numero di caratteri scritti.
Valore di ritorno
Numero di oggetti letti/scritti correttamente, che potrebbe essere inferiore a count
quando si verifica una condizione di errore o di fine file.
Se la dimensione o il conteggio è zero, la funzione restituisce zero e lo stato del flusso e il contenuto puntato da ptrrimangono invariati.
parametri
buffer | – | puntatore al primo oggetto dell’array da leggere |
taglia | – | dimensione di ogni oggetto in byte |
contare | – | il numero degli oggetti da leggere |
file | – | input del flusso di file da cui leggere |
fread e fwrite scrivono a blocchi di byte.Per capire come scrivono bisogna capire come viene scritto in maniera binaria il file
ES.
ciao come stai
bene grazie
Questo file è memorizzato in maniera binaria cosi
01100011 01101001 01100001 01101111 00100000 01100011 01101111 01101101 01100101 00100000 01110011 01110100 01100001 01101001 00001101 00001010 01100010 01100101 01101110 01100101 00100000 01100111 01110010 01100001 01111010 01101001 01100101
Carrige Return e Line Feed
00001101 00001010 ci sono su ogni a capo
e 32
00100000 è lo spazio

char *buffer=new char[100]; int i=0; while(fread(buffer,1,1,f))//legge 1 blocco di un byte alla volta cout<<buffer[0];

Ecco un programma che usando fread compara due file anche se non sono scritti con gli stessi spazi
#include<iostream> #include<stdio.h> #include<string.h> using namespace std; void compareFiles_senza_spazi(FILE *fp1, FILE *fp2) { char *buffer1=new char[30]; char *buffer2=new char[30]; int a = fread(buffer1,1,1,fp1); /*legge il file mette in a un numero di elementi trovati se non trova nulla cioè siamo ad EOF allora mette 0*/ int b = fread(buffer2,1,1,fp2); bool diversi=false; while (a!=0 || b!=0) //finche c'è roba in uno o l'altro file { /*se trova spazi a capo o feed line allora fread va avanti*/ while(((int)buffer1[0]==32 || (int)buffer1[0]==10 || (int)buffer1[0]==13 ) && a!=0) { a = fread(buffer1,1,1,fp1); } /*se trova spazi a capo o feed line allora fread va avanti*/ while(((int)buffer2[0]==32 || (int)buffer2[0]==10 || (int)buffer2[0]==13) && b!=0) { b= fread(buffer2,1,1,fp2); } /*compara due file e mette diversi se sono diversi oppure se esce per colpa di uno che è arrivato alla fine perche se uno è arrivato alla fine vuol dire che non possono essere uguali */ if(strcmp(&buffer1[0],&buffer2[0])!=0 && (b!=0 || a!=0)) { diversi=true; break; } a = fread(buffer1,1,1,fp1); b = fread(buffer2,1,1,fp2); } if(diversi) cout<<"I File sono diversi\n"; else cout<<"I File sono uguali\n"; } int main() { // opening both file in read only mode FILE *fp1 = fopen("file1.txt", "r"); FILE *fp2 = fopen("file2.txt", "r"); if (fp1 == NULL || fp2 == NULL) { printf("Error : Files not open"); exit(0); } compareFiles_senza_spazi(fp1, fp2); // closing both file fclose(fp1); fclose(fp2); return 0; }
LETTURA E SCRITTURA CARATTERI -char
FILE *f=fopen("g.txt","w");//se non c'e lo crea char c; scanf("%c",&c);//legge carattere da tastiera fputc(c,f);//mette il carattere nel file fclose(f);
FILE *f=fopen("g.txt","r");//se non c'e lo crea char c; c=fgetc(f);//mette il carattere nel file cout<<c; fclose(f);
LETTURA E SCRITTURA STRINGHE -*char
int fputs ( const char * str, FILE * stream );
char * fgets ( char * str, int num, FILE * stream );
int fscanf ( FILE * stream, formato,const char * format, … );
int fprintf ( FILE * stream, formato,const char * format, … );
/* Prof. Alessandro Barazzuol */ #include<iostream> #include<string> #include<cstdlib> #include<ctime> #include<iomanip> #include<stdio.h> using namespace std; int main() { FILE *f=fopen("g.txt","w");//se non c'e lo crea int n=75; fprintf(f,"%d",n);//rappresenta 7 come Codice ASCII 55 su 8 bit e 5 come Codice ASCII 53 su 8 bit char c='7'; fprintf(f,"%c",c);//rappresenta sette come numero su 8 bit char *buffer="75"; fprintf(f,"%s",buffer);//rappresenta 7 come Codice ASCII 55 su 8 bit e 5 come Codice ASCII 53 su 8 bit fclose(f); }
Come muoversi in un file binario
Vediamo ora come si può portare avanti e indietro la posizione corrente. Per avanzare di n byte rispetto alla posizione corrente, si fa:
fseek(fd, n, SEEK_CUR);
Per tornare indietro di n byte, ossia spostare la posizione corrente di n byte indietro, si fa:
fseek(fd, -n, SEEK_CUR);
In altre parole, il secondo parametro indica la nuova posizione relativamente a quella vecchia.