Lectura de un archivo carácter por carácter en C

Question

Hola a todos, estoy escribiendo un intérprete BF en C y me he encontrado con un problema al leer archivos. Solía ​​usar scanf para leer la primera cadena, pero luego no podía tener espacios ni comentarios en su código BF.

Ahora mismo esto es lo que tengo.

char *readFile(char *fileName) 
{ 
    FILE *file; 
    char *code = malloc(1000 * sizeof(char)); 
    file = fopen(fileName, "r"); 
    do 
    { 
    *code++ = (char)fgetc(file); 

    } while(*code != EOF); 
    return code; 
} 

Sé que el problema surge en la forma en que estoy asignando el siguiente caracter en el archivo para el puntero del código, pero que no estoy seguro de lo que es.
Me falta conocimiento de mi puntero, que es el objetivo de este ejercicio. El intérprete funciona bien, todos utilizan punteros, solo estoy teniendo problemas para leer archivos.

(Voy a implementar solo lectura "+ -> < [].," En el archivo más tarde, aunque si alguien tiene una buena manera de hacerlo, sería genial si me lo hiciera saber !)

Gracias de antemano

Answer 1

Hay una serie de cosas mal con su código:

char *readFile(char *fileName) 
{ 
    FILE *file; 
    char *code = malloc(1000 * sizeof(char)); 
    file = fopen(fileName, "r"); 
    do 
    { 
     *code++ = (char)fgetc(file); 

    } while(*code != EOF); 
    return code; 
} 

1. ¿Qué pasa si el archivo es mayor que 1.000 bytes?
2. Está aumentando code cada vez que lee un carácter, y devuelve code de vuelta a la persona que llama (aunque ya no apunta al primer byte del bloque de memoria como lo devolvió malloc).
3. Estás emitiendo el resultado de fgetc(file) en char. Debe verificar EOF antes de enviar el resultado al char.

Es importante mantener el puntero original devuelto por malloc para que pueda liberarlo más tarde. Si hacemos caso omiso del tamaño del archivo, podemos lograr esto todavía con lo siguiente:

char *readFile(char *fileName) 
{ 
    FILE *file = fopen(fileName, "r"); 
    char *code; 
    size_t n = 0; 
    int c; 

    if (file == NULL) 
     return NULL; //could not open file 

    code = malloc(1000); 

    while ((c = fgetc(file)) != EOF) 
    { 
     code[n++] = (char) c; 
    } 

    // don't forget to terminate with the null character 
    code[n] = '\0';   

    return code; 
} 

Hay varias llamadas al sistema que le dará el tamaño de un archivo; uno común es stat.

Answer 2

creo que el problema más importante es que se está incrementando a medida que lee code cosas en, y luego devolver el valor final de code, es decir, se le devuelve un puntero al final de la cadena. Probablemente desee hacer una copia de code antes del ciclo, y luego devolverlo.

Además, las cadenas C deben terminarse en nulo. Es necesario asegurarse de que se coloca un '\0' directamente después del carácter final que se lee en

Nota:. Sólo podía usar fgets() para obtener toda la línea en un hit.

Answer 3

Cualquiera de los dos debe hacer el truco -

char *readFile(char *fileName) 
{ 
    FILE *file; 
    char *code = malloc(1000 * sizeof(char)); 
    char *p = code; 
    file = fopen(fileName, "r"); 
    do 
    { 
    *p++ = (char)fgetc(file); 
    } while(*p != EOF); 
    *p = '\0'; 
    return code; 
} 

char *readFile(char *fileName) 
{ 
    FILE *file; 
    int i = 0; 
    char *code = malloc(1000 * sizeof(char)); 
    file = fopen(fileName, "r"); 
    do 
    { 
    code[i++] = (char)fgetc(file); 
    } while(code[i-1] != EOF); 
    code[i] = '\0' 
    return code; 
} 

Al igual que los otros críticos han señalado, es necesario asegurarse de que el tamaño del archivo no supera los 1000 caracteres.Además, recuerde liberar la memoria cuando haya terminado de usarla.

Answer 4

El problema aquí es doble: a) incrementa el puntero antes de comprobar el valor leído, yb) ignora el hecho de que fgetc() devuelve un int en lugar de un char.

El primero se puede arreglar fácilmente:

char *orig = code; // the beginning of the array 
// ... 
do { 
    *code = fgetc(file); 
} while(*code++ != EOF); 
*code = '\0'; // nul-terminate the string 
return orig; // don't return a pointer to the end 

El segundo problema es más sutil - fgetc devuelve un int sonthat el valor EOF puede ser distinguida de cualquier posible valor CHSR. Al solucionar esto, se usa una int temporal para la comprobación de EOF y, probablemente, un bucle while normal en lugar de do/while.

Answer 5

Aquí hay una forma sencilla de hacer caso omiso de todo menos caracteres brainfuck válidos:

#define BF_VALID "+-><[].," 

if (strchr(BF_VALID, c)) 
    code[n++] = c; 

Answer 6

el archivo está siendo abierta y no cerrada por cada llamada a la función también

Answer 7

Ampliando el código anterior de @dreamlax

char *readFile(char *fileName) { 
    FILE *file = fopen(fileName, "r"); 
    char *code; 
    size_t n = 0; 
    int c; 

    if (file == NULL) return NULL; //could not open file 
    fseek(file, 0, SEEK_END); 
    long f_size = ftell(file); 
    fseek(file, 0, SEEK_SET); 
    code = malloc(f_size); 

    while ((c = fgetc(file)) != EOF) { 
     code[n++] = (char)c; 
    } 

    code[n] = '\0';   

    return code; 
} 

Esto le da la longitud del archivo, luego procede a leerlo carácter por carácter.