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 nulloPOSIX 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

bufferpuntatore al primo oggetto dell’array da leggere
tagliadimensione di ogni oggetto in byte
contareil numero degli oggetti da leggere
fileinput 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.

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *