Pagina 1 di 2 1 2 ultimoultimo
Visualizzazione dei risultati da 1 a 10 su 13
  1. #1

    [PILLOLA]C/C++ Lavorare con i File

    Premessa: Essendo un argomento non troppo semplice
    e visto che esistono almeno 3 metodi per la gestione
    dei file ho pensato di suddividerlo in tre capitoli
    distinti secondo questo schema:
    codice:
    Alto Livello
       |
       -libreria <stdio.h>
       |
       -librerie <iostream.h><fstream.h>
    Basso Livello
       -SOTTO LINUX
    In questo primo capitolo gestiremo i file ad Alto Livello
    (Qualsiasi s.o. c e c++) attraverso la libreria standard <stdio.h>
    questa libreria contiene in particolare
    fopen,fclose,fseek,ftell,fwrite,fread,
    fprintf,fscanf,fgetc,fgets,feof
    + operatore sizeof() che andremo ad analizzare uno ad uno.

  2. #2

    PARTE PRIMA: ALTO LIVELLO CON LIBRERIA STANDARD

    fopen:
    la fopen serve per aprire un file, funziona cosi:

    *FILE = fopen("stringa_con_il_nome_del_file",metodo);

    dove metodo puo' essere
    codice:
    "w"  =Crea il file(se esiste lo sovrascrive),il puntatore si posiziona all'inizio
         del file, e' possibile solo scrivere nel file, non leggere
    "r"  =Apre il file solo in lettura,il puntatore si posiziona all' inizio
    "w+" =Crea il file(se esiste lo sovrascrive),il puntatore si posiziona all'inizio
         del file,si puo scrivere e leggere
    "r+" =Apre un file in lettura e scrittura,il puntatore si posiziona all' inizio
    "a"  =Apre il file in append.
    "a+" =Apre il file in append e in lettura.
    int fclose(*FILE);

    chiude un file aperto mentre

    long pos=fteel(*FILE)

    restituisce la posizione nel file(in questo caso chiamata pos).
    Per posizionare il puntatore a una determinata posizione si usa

    int fseek(*FILE,long int offset,int a)

    dove offset puo' essere un valore (con segno)rapresentante
    i byte di spostamento e dove a deve essere
    codice:
    0 per spostarsi partendo dall' inizio del file
    1 per spostarsi partendo dalla posizione corrente
    2 per spostarsi partendo dalla fine del file
    un valore di offset positivo spostera' il puntatore in avanti
    contrariamente si spostera' in indietro.
    codice:
    fread(
        *dove,
        quanti_byte_spostare,
        quante_volte_fare_la_fread, 
        *FILE_DESTINAZIONE
        ); 
    
    fwrite(
        *da_dove,
        quanti_byte_spostare,
        quante_volte_fare_la_fwrite, 
        *FILE_SORGENTE
        );
    fwrite() ed fread vengono usate rispettivamente per leggere e per
    scrivere n byte in un file. e' utile utilizzare l'operatore sizeof() che restituisce
    la dimensione,ad esempio di una struttura,o di un tipo semplice..

    esempio: ho la seguente struttura;
    codice:
    struct pippo {
        int a;
        int b;
    };
    e voglio salvarla in un file,dovrei
    -innanzitutto sapere le specifiche del
    compilatore per il tipo int
    -i bit del sistema operativo (se 16 e' la meta'..)
    -poi per una struttura piu' complessa dovrei fare alcuni calcoli..
    fortunatamente esiste sizeof(struct pippo) che restituisce la dimensione!
    quindi fread/fwrite avranno questa forma:

    fread/fwrite(&struttura, quante_volte_la_salvo/copio, sizeof(struct pippo), destinazione/sorgente);

    ricordo che e bene usarla anche con i tipi primitivi (es:sizeof(int))
    cosi' il codice risultera' piu' portabile..
    fprintf ed fscanf funzionano esattamente come la
    printf e la scanf normali, solo che come primo parametro vogliono il file.
    fprintf(file_destinazione,"stringa da scrivere eventuali valori:%d",eventuale_valore);
    fscanf(file_sorgente,"%d%c",&intero,&carattere);

    da notare che fprintf(stdout,""); ed fscanf(stdin,"");
    sono l'equivalente di printf e scanf.

    fgetc,fgets,fputc,fputs funzionano similmente alle getc,gets,putc,puts normali;
    int fputc(int c,*FILE);
    int fgetc(*FILE);
    *char fgets(*char,DIMENSIONE,*File);
    int fputs(costant *char,*FILE);
    int fgets(,size*FILE);

    feof(*FILE);
    la feof restituisce VERO,TRUE,1 dopo che viene effettuata la lettura
    oltre al file,quindi dopo che una lettura ha dato esito negativo.
    ATTENZIONE: in Basic e' il contrario.

  3. #3

    PROBLEMI CLASSICI

    FILE APERTI IN MANIERA ERRATA:
    se si apre un file con "w" o con "a" e' logico che non si puo'
    leggere dal file..il c vi ritorna caratteri strani o NULL.. quindi
    potete veder stampato cose del genere
    [][][][]
    ****
    soluzione:
    controllare il file e aprirlo nella maniera piu' opportuna

    MI SCRIVE UN RECORD IN PIU'
    se si fa un output all'interno di un ciclo con controllo feof()
    feof restituira' VERO solo DOPO aver letto almeno una volta oltre al
    file.. questo vuol dire che se stampate una variabile,o una struttura
    all'interno di questo ciclo stamperete 2 volte l'ultima.

    SOLUZIONE mettere un if feof(*FILE)break; appena dopo la prima lettura
    che puo' generare errore.

    ESEMPIO:
    codice:
    while( !feof(input) )
    {
        fread(&a, sizeof(char), 1, input);
        
        if( feof(input) )
            break;
        
        putchar(a);
    };

  4. #4

    TRICKs

    Molte volte si ha la necessita' di dover salvare,ad esempio un archivio
    per poi modificarlo, o aggiungere dati.
    se il programma e' al primo avvio, il record non esistera' e si dovra' crearlo
    occorrera' allora adoperare questo sistema:
    Codice PHP:
    FILE *dati;
    if((
    dati=fopen("data.dat","r"))==NULL)dati=fopen("data","w+");
    else { 
    fclose(dati);
           
    dati=fopen("data.dat","r+"); 
         } 
    per un motivo,che adesso mi sfugge, non conviene aprirlo direttamente con "r+"
    ma fare una prova prima con "r".

  5. #5

    PARTE 2 Stream(C++)

    il c++ utilizza gli stream e gli oggetti :
    la libreria iostream.h
    fornisce 2 operatori:>> e <<
    rispettivamente per l'input e l'output.

    i file vengono gestiti con la classe fstream che ha questi metodi:
    codice:
    open();  per aprire uno stream
    close(); per chiuderlo
    eof();   per segnalare la fine file
    good();  true se non ci sono stati errori
    fail();  true se ci sono stati
    seekg(); per spostarsi all'interno del file
    write(); per scrivere
    read();  per leggere
    oltre a write e a read si possono usare << e >>.

    La prossima volta verra' approfondito questo argomento

  6. #6

    PROBLEMI CLASSICI(2)

    mi sono completamente dimenticato di dire che nella stringa
    contenente il pathname e il nome del file
    le barre '\' di separazione del path vanno messe in questo modo:

    se il path e' c:\pippo\prova.c

    va' caricato con:
    codice:
    Input=fopen("c:\\pippo\\prova.c");
    questo perche' i caratteri di escape in c vengono parsati prima della compilazione nella stringa..(circa, adesso non spiego..)

    quindi se il path fosse stato
    c:\root\nello ci sarebbero stati dei casini, xke' il compilatore
    avrebbe interpretato \r come "ritorno del carrello" e \n come "a capo"

    quindi per evitare questo noi mettiamo il carattere di escape della \
    che e' \\ !!!

  7. #7
    io non ho capito perchè non mi funzia questo programma che dovrebbe essere da idioti!
    codice:
    #include <stdio.h>
    #include <stdlib.h>
    
    main(){
    FILE *filepuntatWRITE=fopen("file.txt","w");
    char a[80];
    FILE *filepuntatREAD=fopen("file.txt","r"); 
    char string[80]="prova file sno gau";
    printf("%s","ciao\n");
    if (filepuntatWRITE) {
    	fprintf(filepuntatWRITE,"%c",string);
    
    }
    	else printf("sei scemo\n");
    		printf("%s","\ntuttobene\n");
    	fclose(filepuntatWRITE);
    
    	printf("Ora ti faccio vedere cosa sta scritto sul file:\n") ;
    
    		if (filepuntatREAD){
    			
    			while(!feof(filepuntatREAD))  {
    			fscanf(filepuntatREAD,"\n%c",&a); 
    			if(!feof(filepuntatREAD))
    				printf("%c",a);
    			}
    		}
    		else	printf("\nQulcosa non è andato molto bene:****ERRORE");
    
    		printf("\n\n**********FINE******\n\n");
    		fclose(filepuntatREAD);
    	
    
    
    
    return 0;
    }

  8. #8
    devi fare fflush(filepuntatWRITE);
    per svuotare il buffer altrimenti succede che quello che scrivi nel
    file rimane nel buffer finche' quest' ultimo e pieno(il buffer
    e' un area dati in ram..)
    soprattutto sotto Linux dove l' I/O e' bufferizzato di default..
    comunque invece di usare 2 puntatori sequenziali usane uno solo in lettura e scrittura..
    poi tu usi 2 if "strane"
    if (filepuntatWRITE)
    ed
    if (filepuntatREAD)
    siccome NULL non e' detto sia 0, anzi in certi os e' uguale a -1
    non funziona la if, devi modificarle rispettivamente in

    if (filepuntatWRITE!=NULL)
    ed
    if (filepuntatREAD!=NULL)

  9. #9
    devo riuscire a farlo solo col c!
    non riesco a fare un prog funzionante che LEGGA il file!!

  10. #10
    Utente bannato
    Registrato dal
    Apr 2004
    Messaggi
    1,392
    Uso getc
    codice:
    buffer = fgetc(pointer);
    Per leggere da un file, però mi legge solo il primo carattere... Io vorrei leggerlo tutto, come posso fare?

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.