[C] Copiare file in una stringa

[xbubbax]

Ho fatto una semplice funzione per copiare il testo di un file in una stringa ma mi da errore quando lo eseguo, esce il solito errore di windows, "non inviare"... come mai?

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

static char* readFile(FILE *  in){
       
/* Copia il file di input in una stringa e la restituisce. */
       
       char c=0;
       static char *s;
       
       while(c!=EOF){
                     
                     c=fgetc(in);
                     *s=c;
                     *s=*s+1;}
                     
       return s;}

int main(void){
    
    FILE *f1;
    static char *s;
    
    f1=fopen("prova.txt", "r");
    
    *s=readFile(f1);
    
    printf("%s\n", s);
    
    system("PAUSE");}

[71104]

perché all'interno di readFile non hai allocato s

[xbubbax]

in che senso? non capisco...

[andbin]

Originariamente inviato da xbubbax

in che senso? non capisco...

's' è una variabile static (vuol solo dire che è a durata "fissa", non è allocata sullo stack). Ma è un puntatore non inizializzato .... non si sa a cosa punta.
Devi prima fare in modo che 's' punti ad una area di memoria di dimensione sufficiente per quello che devi fare.

Anche la chiamata non va bene:
*s=readFile(f1);

L'asterisco non ci vuole.

E guardando meglio la funzione:
*s=*s+1;

non è tecnicamente sbagliato ma non ha molto senso (non so cosa volevi fare ... incrementare il puntatore?)

[xbubbax]

da quanto tempo andbin

allora ho tolto l'asterisco dove non andava bene...

con *s=*s+1 voglio incrementare la stringa, cioè passare alla locazione successiva dove memorizzare un carattere preso dal file. è sbagliato?

non capisco ancora come allocare s all'interno della funzione. devo usare malloc? se si come?

[andbin]

Originariamente inviato da xbubbax

con *s=*s+1 voglio incrementare la stringa, cioè passare alla locazione successiva dove memorizzare un carattere preso dal file. è sbagliato?

No non va bene. L'operatore di dereferenziazione * ha priorità maggiore del +, quindi prima prenderebbe il carattere puntato da s (es. 'a'), poi lo incrementa di 1 (diventa 'b') e poi lo assegna di nuovo nel carattere puntato da s.

Se vuoi incrementare il puntatore basta che fai s++;

In ogni caso leggere 1 byte per volta è inefficiente e scomodo. Meglio usare fread() per leggere un blocco di byte.

Originariamente inviato da xbubbax

non capisco ancora come allocare s all'interno della funzione. devo usare malloc? se si come?

Sì con malloc. Se non conosci a priori la dimensione del file, ci sono diversi scenari:
a) Aprire il file, fare una fseek() al fondo e determinare la lunghezza con ftell(), quindi fare una fseek() all'inizio. In tal caso si alloca un unico blocco di memoria che può già contenere l'intero file.
b) Allocare inizialmente un tot di memoria che poi viene riallocata man mano che serve facendo un ciclo di N letture.
c) Allocare un tot di memoria sufficientemente grande e leggere al massimo per quella dimensione, non di più.

[xbubbax]

io ho sempre usato malloc solo con le liste, non ho idea di cosa inserire ora, cioè di come allocare memoria.

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

static char* readFile(FILE *  in){
       
/* Copia il file di input in una stringa e la restituisce. */
       
       char c=0;
       static char *s=(   )malloc(sizeof( ));
       
       while(c!=EOF){
                     c=fgetc(in);
                     *s=c;
                     s++;}                    
       return s;}

int main(void){
    
    FILE *f1;
    static char *s;
    
    f1=fopen("prova.txt", "r");
    
    s=readFile(f1);
    
    printf("%s\n", s);
    
    system("PAUSE");}

[andbin]

Originariamente inviato da xbubbax

non ho idea di cosa inserire ora, cioè di come allocare memoria.

Ma è appunto lì la questione, ho anche spiegato le varie possibilità. Dipende tutto da come vuoi gestire il (ri)dimensionamento dell'area di memoria.

[xbubbax]

sisi ho capito che vuoi dire, il problema mio è proprio scrivere le righe di codice, ovvero la sintassi. non ho mai usato quelle funzioni che hai nominato

[xbubbax]

andbin dei modi che mi hai elencato per allocare memoria quale mi conviene usare?

[andbin]

Originariamente inviato da xbubbax

andbin dei modi che mi hai elencato per allocare memoria quale mi conviene usare?

Io direi quella che ho indicato con a). Determini prima la dimensione del file, allochi memoria esattamente per quella dimensione e quindi carichi tutto il file.

[xbubbax]

Vada per la a. Sto cercando le funzioni che mi servono ma non ho idea di come usarle.

int fseek(FILE *stream, long offset, int whence);

long ftell(FILE *stream);

non so come usarle, non l'ìho mai fatto, mi puoi fare un esempio simile al mio...

[andbin]

Ecco un esempio che avevo già scritto in passato:

long get_file_size (FILE *stream)
{
    long pos, size;

    if ((pos = ftell (stream)) == -1)
        return -1;   /* errore */

    if (fseek (stream, 0, SEEK_END) != 0)
        return -1;   /* errore */

    if ((size = ftell (stream)) == -1)
        return -1;   /* errore */

    if (fseek (stream, pos, SEEK_SET) != 0)
        return -1;   /* errore */

    return size;
}

È molto "generica" perché si preoccupa di salvare/ripristinare la posizione corrente, qualunque essa sia.
Se non ti è chiaro, chiedi pure.

[xbubbax]

quindi se ho capito bene devo fare una funzione apposta per calcolare la lunghezza del file o posso includerla nella mia funzione?

una volta che ho fatto questo cosa devo assegnare al puntatore static char*s?

size? o cosa

[andbin]

Originariamente inviato da xbubbax

quindi se ho capito bene devo fare una funzione apposta per calcolare la lunghezza del file o posso includerla nella mia funzione?

Se vuoi usare la "mia" funzione così come è, basta che la metti ad esempio all'inizio del tuo sorgente.
L'ho postata perché capissi il concetto. Non sei obbligato ad usare la mia funzione, puoi anche solo chiamare le singole fseek/ftell dove ti servono. Basta che fai le 3 fasi indispensabili: a) sposti al fondo, b) leggi la lunghezza, c) sposti all'inizio.

Originariamente inviato da xbubbax

una volta che ho fatto questo cosa devo assegnare al puntatore static char*s?

La lunghezza ottenuta la passi a malloc, che ti dà un puntatore all'area allocata che poi assegni alla tua variabile puntatore.

[xbubbax]

in teoria dovrebbe venire una cosa del genere?

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

static char* readFile(FILE *  in){
       
/* Copia il file di input in una stringa e la restituisce. */

    long pos, size;
    char c=0;
    static char *s;

    if ((pos = ftell (in)) == -1)
        return -1;   /* errore */

    if (fseek (stream, 0, SEEK_END) != 0)
        return -1;   /* errore */

    if ((size = ftell (in)) == -1)
        return -1;   /* errore */

    if (fseek (stream, pos, SEEK_SET) != 0)
        return -1;   /* errore */

    s=malloc(sizeof(size));

       
       
       while(c!=EOF){
                     c=fgetc(in);
                     *s=c;
                     s++;}                    
       return s;}

int main(void){
    
    FILE *f1;
    static char *s;
    
    f1=fopen("prova.txt", "r");
    
    s=readFile(f1);
    
    printf("%s\n", s);
    
    system("PAUSE");}

però mi da errore sui vari return -1 dei tuoi if, penso perchè la mia funzione non deve ritornare un intero.

[andbin]

Originariamente inviato da xbubbax

in teoria dovrebbe venire una cosa del genere?

Concettualmente sì, salvo gli errori che tra poco ti riporto.

Originariamente inviato da xbubbax

    if ((pos = ftell (in)) == -1)
        return -1;   /* errore */

La mia funzione ritorna un long, quindi per indicare errore ho fatto ritornare -1, che sicuramente non è una lunghezza valida.

Nella tua funzione non puoi far ritornare -1! Infatti restituisce un char*. Presta meglio attenzione alla gestione degli errori. Piuttosto fai ritornare NULL in caso di errore (e nel main dovrai ovviamente anche testarlo).

Originariamente inviato da xbubbax

s=malloc(sizeof(size));

sizeof fornisce la dimensione in byte di una variabile o un tipo, quindi non va bene. Visto che size è un long, sizeof(size) ritorna sempre 4 su un sistema a 32 bit!!

s=malloc(size);

Originariamente inviato da xbubbax

       while(c!=EOF){
                     c=fgetc(in);
                     *s=c;
                     s++;}

Come avevo già detto, leggere un byte per volta è scomdo ed inefficiente. Usa fread().

[xbubbax]

ho corretto tutto ma mi da ancora errore.

per la fread basta sostituirla alla fgetc oppure devo includere qualche libreria?

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

static char* readFile(FILE *  in){
       
/* Copia il file di input in una stringa e la restituisce. */

    long pos, size;
    char c=0;
    static char *s;

    if ((pos = ftell (in)) == -1)
        return NULL;   /* errore */

    if (fseek (in, 0, SEEK_END) != 0)
        return NULL;   /* errore */

    if ((size = ftell (in)) == -1)
        return NULL;   /* errore */

    if (fseek (in, pos, SEEK_SET) != 0)
        return NULL;   /* errore */

    s=malloc(size);

       
       
       while(c!=EOF){
                     c=fgetc(in);
                     *s=c;
                     s++;}                    
       return s;}

int main(void){
    
    FILE *f1;
    static char *s;
    
    f1=fopen("prova.txt", "r");
    
    s=readFile(f1);
    
    printf("%s\n", s);
    
    system("PAUSE");}
    
   

[andbin]

Originariamente inviato da xbubbax

    s=malloc(size);
       
       while(c!=EOF){
                     c=fgetc(in);
                     *s=c;
                     s++;}                    
       return s;}

Il valore di ritorno della malloc dovresti anche testarlo.

Non è sufficiente sostituire fread() a fgetc() sono due cose diverse. fread() è sempre in stdio come per fgetc/fseek/ftell.

Poi non ti sei reso conto di una cosa: nel ciclo incrementi il puntatore s e va bene. Ma poi alla fine restituisci proprio quello, che ormai punta dopo la fine del blocco di memoria!!!

[xbubbax]

quindi mi salvo la testa del puntatore pèrima di entrare nel while


e per quanto riguarda la malloc non ho capito che vuoi dire... ti riferisci al test nel main?