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 countoggetti nell’array bufferdal flusso di input dato streamcome 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 countoggetti binari dall’array specificato bufferal 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 countquando 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.