[C++] lettura di un file

[kuarl]

Salve ,
ci sto sbattendo da alcuni giorni..... vorrei capire in che modo C++ accede ai file ed essendo piskello di questo linguaggio vi prego di non darmi nozioni teoriche, fatemi un esempio, ho il file "f:/pippe.txt" e lo voglio tutto in una variabile char *lunedi;

come si fa??

ho letto anche questa pillola:
http://forum.html.it/forum/showthrea...hreadid=477366
stavo cercando di approfondire la questione fread e fgets per leggere....

[iguana13]

Vuoi usare in stile C oppure C++?

//Questo per il sistema I/O in C++
#include <fstream.h>
//Questo per il C
#include <stdio.h>

perchè fread e fgets sono C ...

[kuarl]

Originariamente inviato da iguana13
Vuoi usare in stile C oppure C++?

//Questo per il sistema I/O in C++
#include <fstream.h>
//Questo per il C
#include <stdio.h>

perchè fread e fgets sono C ...

guarda sono disperato, conoscendo php sarei propenso per fread (quindi C) ma d'altra parte conosco molto bene java con le relative classi di gestione, quindi C++

il problema è ke essendo novizio di C++ non riesco a far andare niente

[iguana13]

Ok
Ora ti preparo 1 bell' esempio

[pixer]

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

int main()
{
   FILE * pFile;
   char string [100];

   pFile = fopen ("pippe.txt" , "r");
     fgets (string , 100 , pFile);
	 printf(string); /* stampa la stringa */
     fgets (string , 100 , pFile);
	 printf(string);

	 fclose (pFile);
	 printf("\n");
	 system("pause");
  
  return 0;
}

[Yojimbo]

volendo si possono usare le classi del C++ standrd per accedere ai file come stream, ma sinceramente, non ne ho mai trovato il motivo,uso sempre le funzioni C

[iguana13]

Cominciamo con la gestione dei file in C.
Il file header da includere è:

#include <stdio.h>
//Oppure in stile C++
#include <cstdio>

Ogni variabile "file" sarà un puntatore al tipo "FILE", definito in questo header.
Ad esempio, per dichiarare una variabile FILE:

FILE *fp;

Prima di eseguire qualsiasi operazione, bisogna "aprire" un file.
Per farlo si usa la funzione fopen() che restituisce un puntatore a FILE.
Il suo prototipo è:

FILE *fopen(char *nomefile, char *modalità);

nomefile è un puntatore a caratteri (quindi una stringa) che specifica nome e percorso del file.

modalità è anche una stringa che specifica la modalità di apertura del file.
I valori possono essere:

• r - Apre un file di testo in lettura
• w - Crea un file di testo in scrittura
• a - Apre un file in modalità append (aggiunta di dati)
• rb - Apre un file binario in lettura
• wb - Crea un file binario in scrittura
• ab - Crea un file binario in modalità append
• r+ Apre un file di testo in lettura / scrittura
• w+ - Crea un file di testo in lettura/scrittura
• a+ - Crea o Apre un file di testo in mod. append per scrittura / lettura
• r+b - Apre un file binario in lettura / scrittura
• w+b - Crea un file binario in lettura / scrittura
• a+b - mod. append, binario, lettura/scrittura

Questo codice apre in output un file chiamato test:

FILE *fp;
fp = fopen("C:\\test.txt","w");

Le modalità di apertura testo / binario differiscono di poco.

Quando si finisce di usare un file, se lo chiude con close():

FILE *fp;
fp = fopen("C:\\test.txt","w");
//Ho finito di usarlo
fclose(fp);

Ma ora passiamo alla scrittura e lettura vera e propria su un file :metallica

Scrittura di un carattere

Prototipo funzione: int putc(int car, FILE *fp);

Uso:
Scrive il carattere car sul file puntato da fp.

//Scrive '!' su un file
FILE *fp;
fp = fopen("C:\\test.txt","w");
putc('!',fp);
//Ho finito di usarlo
fclose(fp);

Lettura di un carattere

Prototipo funzione: int getc(FILE *fp);

Uso:
Legge un carattere dal file puntato da fp

Esempio:
Legge il primo farattere di un file e lo scrive.

FILE *fp;
char c;
fp = fopen("C:\\test.txt","w");
c=getc(fp);
printf("%c",c);
fclose(fp);

Lettura di una stringa


Prototipo funzione: char *fgets(char *str, int lunghezza,FILE *fp)

Uso:
Legge lunghezza caratteri dal file puntato da fp e li inserisce in *str.
Quando incontra il carattere di fine riga, termina ugualmente la stringa ma non lo memorizza.

Esempio:
Legge la prima riga (o al limite i primi 255 caratteri) da un file e li scrive.

FILE *fp;
char str[256];

fp = fopen("C:\\test.txt","r");

fgets(str,256,fp);

puts(str);

fclose(fp);

Determinare la fine di un file

Per vedere, durante la lettura, se si ha raggiunto la fine di un file, si usa la funzione feof();

Prototipo:

int feof(FILE *fp);

Restituisce il valore logico vero (1) se la fine del file è stata raggiunta.

Esempio:
Legge tutti i caratteri da un file binario e li scrive.

FILE *fp;
char ch;

fp = fopen("C:\\test.txt","r");
do {
    c = getc(fp);
    printf("%c",c);
} while (!feof(fp));

fclose(fp);

Cancellazione di file

La funzione da usare è remove()

int remove(char *nomefile);

cancella irrimediabilmente il file nomefile.







Ora devo andare... alla prossima puntata! :sexpulp:

[Yojimbo]

o se vuoi cose + veloci e di + basso livello, ci sono le 4 funzioni di base ma sotto win32 non saprei dirti in che header o se anno cambiato i nomi delle flag

[kuarl]

ok tutto chiaro..... ora il problema per me rimangono le stringhe.....
ad es. ho visto ke la funzione fgets legge una riga.... ma in realtà devi imporre un limite, a mio avviso la riga può essere anche di 2000 caratteri e con fgets devi sempre approssimare :quipy:

la soluzione ovvia sarebbe leggere carattere per carattere, concatenare ogni carattere letto ad una stringa e fermarsi quando si raggiunge il carattere di fine riga, in java nessun problema, in php nessun problema.... ed in C.....

come minkia si fa??

ad es. come faccio a leggere un file di dimensione arbitraria e memorizzarlo in una stringa?

grazie ancora per l'aiuto

[Yojimbo]

Indovina, nn puoi, ma pensa che il Java e PHP sono interpretati da parti in C... quindi un modo c'è, ponendo limiti alla lunghezza della stringa nel file o leggi tu a blocchi di byte, e verifichi in seguito in memoria dove è la fine lineaa,per avere alte prestazioni devi ridurre il numero di chiamate il + possibile a funzioni di input outut, quindi pensa a creare un vettore ( buffer ) di almeno 4K o allochi dinamicamente un buffer