Visualizzazione dei risultati da 1 a 8 su 8
  1. #1

    Aiuto sui file in C

    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.

  2. #2
    Utente bannato
    Registrato dal
    Sep 2003
    Messaggi
    1,012
    Sarebbe lungo scriverteli tutti, è meglio che ti cerchi una guida su internet.

    www.cppreference.com

    Se cerchi in qualche vecchio thread trovi qualcosa.


  3. #3
    Utente di HTML.it L'avatar di infinitejustice
    Registrato dal
    Nov 2001
    residenza
    Barcelona
    Messaggi
    773
    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
    Live fast. Troll hard.
    Pythonist | Djangonaut | Puppeteer | DevOps | OpenStacker | Lost in malloc
    Team Lead @Gameloft Barcelona

  4. #4
    Utente di HTML.it L'avatar di infinitejustice
    Registrato dal
    Nov 2001
    residenza
    Barcelona
    Messaggi
    773
    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

    codice:
    #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);
    }
    Live fast. Troll hard.
    Pythonist | Djangonaut | Puppeteer | DevOps | OpenStacker | Lost in malloc
    Team Lead @Gameloft Barcelona

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

    grazie mille!!!!!!

  6. #6
    Utente di HTML.it L'avatar di infinitejustice
    Registrato dal
    Nov 2001
    residenza
    Barcelona
    Messaggi
    773
    Originariamente inviato da MaxMe
    we raga, siete mitici faccio un copia/incolla e via
    voglio il copirait
    Live fast. Troll hard.
    Pythonist | Djangonaut | Puppeteer | DevOps | OpenStacker | Lost in malloc
    Team Lead @Gameloft Barcelona

  7. #7
    Originariamente inviato da infinitejustice
    voglio il copirait
    © eccolo

    aggiungo alle pillole!
    http://forum.html.it/forum/showthrea...hreadid=214612
    ...Terrible warlords, good warlords, and an english song

  8. #8
    Moderatore di Programmazione L'avatar di alka
    Registrato dal
    Oct 2001
    residenza
    Reggio Emilia
    Messaggi
    23,826
    "BUMP!"

Permessi di invio

  • Non puoi inserire discussioni
  • Non puoi inserire repliche
  • Non puoi inserire allegati
  • Non puoi modificare i tuoi messaggi
  •  
Powered by vBulletin® Version 4.2.1
Copyright © 2019 vBulletin Solutions, Inc. All rights reserved.