Pillola: [C] Le funzioni per l'accesso, la lettura e la scrittura di file

[MaxMe]

Salve, sono uno studente di informatica. Devo fare una ricerca sui file in linguaggio C. e vorrei sapere le funzionalità, e la sintassi
(se è possibile) di questi argomenti riguardanti i file.

1-fopen.
2-fcolse.
3-fread.
4-fwrite.
5-rewind.
6-fseek.
7-ftell.
8-buffer.

vi ringrazio anticipamente per le risposte.

[iguana13]

Sarebbe lungo scriverteli tutti, è meglio che ti cerchi una guida su internet.

www.cppreference.com

Se cerchi in qualche vecchio thread trovi qualcosa.

[infinitejustice]

Ti faccio un copia/incolla dai miei vecchi! appunti dell'esame di programmazione (quindi nn aspettarti chissà cosa)

fopen() prototipo: FILE *fopen(const char *filename, const char *mode);
L'associazione dello stream al file avviene mediante la funzione di libreria fopen(), che riceve, come parametri, due stringhe, nell'ordine: nome del file (path relativa o assoluta) e modalità di apertura del medesimo.

Aprire un file significa rendere disponibile un canale di accesso al medesimo, attraverso il quale leggere e scrivere dati.

Può essere utile in fase di dichiarazione di puntatore a FILE dichiarare anche una stringa costante indicante il nome del file.
const char *fileName = "yomama.txt";

Il secondo parametro indica invece la modalità di apertura dello stream. Le possibilità sono molte:

r Read only. Il file deve esistere.

w Sul file sono possibili solo operazioni di scrittura. Il file, se esiste viene viene troncato a 0 byte; se non esiste viene creato.

a Sul file sono possibili solo operazioni di scrittura, ma a partire dal termine del file stesso, se esistente. In caso contrario viene creato.

r+ Lettura e scrittura su file già esistente.

w+ Lettura e scrittura. Il file, se esiste viene viene troncato a 0 byte; se non esiste viene creato.

a+ Lettura e scrittura. Quest'ultima a partire dal termine del file stesso, se esistente. In caso contrario viene creato.

A tutte le modalità può inoltre essere aggiunta una b per far sì che il processo avvenga in modalità binaria.
Il valore di ritorno della funzione è un puntatore a FILE, ovvero uno stream; NULL in caso di errore.
Il numero massimo di file contemporaneamente aperti varia da macchina a macchina e da compilatore a compilatore. Tale valore è comunque rappresentato da
int FOPEN_MAX.


fcolse()
prototipo: int fclose(FILE *stream);
Al termine delle operazioni sul file è opportuno chiuderlo, cioè rilasciare le risorse di sistema. La funzione fclose() chiude uno stream aperto da una chiamata a fopen(), scrive nel file i dati rimasti ancora nel buffer quindi lo chiude. Allo stesso tempo esegue un free() sul blocco di memoria associato allo stream appena chiuso, liberandolo.

Il valore di ritorno è 0 in caso di successo nell'operazione di chiusura. Al contrario, un errore genera EOF.

Generalmente la funzione fclose() fallisce solo quando il disco è stato tolto o se non c'è spazio sufficiente per scrivere e chiudere.


rewind()
prototipo: void rewind(FILE *stream);
Altra funzione essenziale è rewind(). Come abbiamo accennato prima, nella librearia stdio.h è presente una variabile, fpos_t, che indica la posizione all’interno del file.
Tutte le funzioni di lettura e scrittura muovono la posizione automaticamente evitando di sovrascrivere o leggere più volte lo stesso dato.

Vediamo un esempio. Creiamo un nuovo file nel quale scriviamo delle stringhe, quindi ripartendo dall’inizio leggiamo e stampiamo il suo contenuto.

#include <stdlib.h>
#include <string.h>

const char *FileName = "C:\\yoyoyo.txt";

void main(){
char str[80];
FILE *myFile;
if(!(myFile = fopen(FileName,"w+"))){
printf("Error while trying to open %s", FileName);
exit (-1);
}
do{
printf("Enter a string: ");
gets(str);
strcat(str, "\n");
fputs(str, myFile);
}
while(*str != '\n');
rewind(myFile);
while(!feof(myFile)){
fgets(str, 79, myFile);
printf(str);
}
}

fseek() + ftell()
prototipo: int fseek(FILE *fp, long int numbytes, int origin);
Questa funzione permette di muoversi all’interno del file, aperto in modalità binaria, indicato dal primo parametro.

Il secondo parametro permette di decidere di quanto muoversi ed in che direzione: un valore positivo indica un movimento in avanti, uno negativo all’indietro mentre lo zero indica che non c’è movimento.

Importante: il secondo parametro non è un int, ma un long.

L’ultimo parametro indica invece da dove si vuole iniziare a cercare.
Vi sono tre macro che possono essere utilizzate come terzo parametro:

SEEK_SET indica l’inizio del file.
SEEK_CUR indica la posizione corrente.
SEEK_END indica invece la fine.

Vediamo subito un interessante codice che, dopo aver aperto in lettura un file, lo stampa a video al contrario.

#include <stdio.h>
#include <stdlib.h>
#define CNTL_Z '\032' // EOF marker in DOS text files

FILE *myFile;
const char *filename = "C:\\temp.txt";

void main(){

char ch;
long count, last;

//Cannot open file...
if(!(myFile = fopen(filename,"r"))){
abort();
}

fseek(myFile, 0L, SEEK_END); //Go to end of file
last = ftell(myFile);

for (count = 1L; count <= last; count++){
fseek(myFile, -count, SEEK_END); //Go backward
ch = getc(myFile);
if(ch != CNTL_Z && ch != '\r')
putchar(ch);
}
fclose(myFile);
}


All’interno del codice abbiamo anche utilizzato la funzione ftell(), il cui prototipo è long ftell ( FILE *fp );, funzione che ritorna la posizione corrente all’interno del file, ovvero il numero di bytes dall’inizio del file, indicato da uno zero.

Ovviamente questa funzione, lavorando sui bytes è utilizzabile solo quando lavoriamo in modalità binaria sui file.

Queste due funzioni sono originarie di Unix, che come sappiamo (o no?) lavora coi soli file binari. E’ garantita portabilità e compatibilità coi file testuali, ma solo con le seguenti dichiarazioni:

fseek(file, 0L, SEEK_SET) //Inizio del file
fseek(file, 0L, SEEK_CUR) //Posizione corrente
fseek(file, 0L, SEEK_END) //Fine del file
fseek(file,ftell-pos,SEEK_SET) //Posizione corrente, ritornata da ftell()

fwrite()
prototipo: size_t fwrite(const void *ptr, size_t size, size_t n, FILE *stream);
La funzione fwrite() scrive in modalità binaria su un file.

Il primo parametro è un puntatore di qualunque tipo, che punta all’area di memoria di ciò che si vuole scrivere sul file.

Il secondo parametro indica la quantità di dati da copiare, mentre il terzo la grandezza ci ciascuno di questi dati.

Infine il quarto parametro, che indica semplicemente il file su cui scrivere.

Il valore di ritorno, in caso di successo, indica il numero di elementi scritti su file, ovvero lo stesso numero indicato come terzo parametro.

fread()
prototipo: size_t fread(void *ptr, size_t size, size_t n, FILE *stream);
Del tutto analoga alla precedente, se non per il fatto di leggere dati da uno stream e di passarli in una locazione di memoria puntata dal primo parametro.


:quipy: sulla modalità binaria potevo scrivere di piu... va beh presi 30 kissene :metallica


mi manca buffer

[infinitejustice]

p.s. ho dimenticato di copiarti l'esempio di fwrite()/fread()
Questo appende n files (a tua scelta quanti e quali) in uno nuovo
Ci avevo messo anche parekki commenti quindi dovrebbe essere di facile comprensione

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

#define BUFSIZE 1024	//Grandezza in bytes del buffer
#define SLEN 20		//Lunghezza max nome files

void append(FILE *, FILE *);	//Parametri: file da appendere, file in cui appendere

void main(){

    FILE *fileAppend, *fileSource;
    int files = 0;  // Nr file appesi
    char file_app[SLEN];  // Nome file in cui appendere tutti gli altri
    char file_src[SLEN];  // Nome file da appendere

	puts("Enter name of destination file:");
    gets(file_app);

	if(!(fileAppend = fopen(file_app, "a")))
		abort();

	//Ridefiniamo la dimensione del buffer. In tal modo possiamo passare fino a BUFSIZE bytes per volta
    if(setvbuf(fileAppend, NULL, _IOFBF, BUFSIZE)){		//0 è il valore ritornato in caso di successo.
        fputs("Can't create output buffer\n", stderr);
        abort();
    	}

	puts("Enter name of first source file (empty line to quit):");
		while(gets(file_src) && file_src[0] != '\0'){		//Se il primo char della stringa ne indica la fine allora non è stato inserito nulla
			if(strcmp(file_src, file_app) == 0)
            	fputs("Can't append file to itself\n",stderr);
			else if(!(fileSource = fopen(file_src, "r"))){
				fprintf(stderr, "Can't open %s\n", file_src);
				break;
				}

			append(fileSource, fileAppend);
            fclose(fileSource);
            files++;
            printf("File %s appended.\n", file_src);
            puts("Next file (empty line to quit):");
			}

    printf("Done. %d files appended.\n", files);
    fclose(fileAppend);
}

void append(FILE *source, FILE *dest){

	size_t bytes;
    static char temp[BUFSIZE]; 	//Variabile statica, allochiamo solo una volta.

    while ((bytes = fread(temp,sizeof(char),BUFSIZE,source)) > 0)
        fwrite(temp, sizeof(char), bytes, dest);
}

[MaxMe]

we raga, siete mitici faccio un copia/incolla e via

grazie mille!!!!!!

[infinitejustice]

Originariamente inviato da MaxMe
we raga, siete mitici faccio un copia/incolla e via

voglio il copirait

[Johnny_Depp]

Originariamente inviato da infinitejustice
voglio il copirait

© eccolo

aggiungo alle pillole!
http://forum.html.it/forum/showthrea...hreadid=214612

[alka]

"BUMP!"