¿Forma correcta de leer un archivo de texto en un búfer en C? [duplicate]

Estoy lidiando con pequeños archivos de texto que quiero leer en un búfer mientras los proceso, así que se me ocurrió el siguiente código:

...
char source[1000000];

FILE *fp = fopen("TheFile.txt", "r");
if(fp != NULL)
{
    while((symbol = getc(fp)) != EOF)
    {
        strcat(source, &symbol);
    }
    fclose(fp);
}
...

¿Es esta la forma correcta de poner el contenido del archivo en el búfer o estoy abusando strcat()?

Luego itero a través del búfer así:

for(int x = 0; (c = source[x]) != '\0'; x++)
{
    //Process chars
}

char source[1000000];

FILE *fp = fopen("TheFile.txt", "r");
if(fp != NULL)
{
    while((symbol = getc(fp)) != EOF)
    {
        strcat(source, &symbol);
    }
    fclose(fp);
}

Hay bastantes cosas mal con este código:

1. Es muy lento (está extrayendo el búfer un carácter a la vez).
2. Si el tamaño del archivo ha terminado sizeof(source)esto es propenso a desbordamientos de búfer.
3. Realmente, cuando lo miras más de cerca, este código no debería funcionar en absoluto. Como se indica en las páginas man:

los strcat() agrega una copia de la cadena terminada en nulo s2 al final de la cadena terminada en nulo s1, luego agrega un ‘\0’ de terminación.

Está agregando un carácter (¡no una cadena terminada en NUL!) a una cadena que puede o no terminar en NUL. los solamente El momento en que puedo imaginar que esto funcione de acuerdo con la descripción de la página de manual es si cada carácter en el archivo termina en NUL, en cuyo caso esto sería bastante inútil. Así que sí, esto es definitivamente un terrible abuso de strcat().

Las siguientes son dos alternativas para considerar usar en su lugar.

Si conoce el tamaño máximo del búfer con anticipación:

#include <stdio.h>
#define MAXBUFLEN 1000000

char source[MAXBUFLEN + 1];
FILE *fp = fopen("foo.txt", "r");
if (fp != NULL) {
    size_t newLen = fread(source, sizeof(char), MAXBUFLEN, fp);
    if ( ferror( fp ) != 0 ) {
        fputs("Error reading file", stderr);
    } else {
        source[newLen++] = '\0'; /* Just to be safe. */
    }

    fclose(fp);
}

O, si no lo hace:

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

char *source = NULL;
FILE *fp = fopen("foo.txt", "r");
if (fp != NULL) {
    /* Go to the end of the file. */
    if (fseek(fp, 0L, SEEK_END) == 0) {
        /* Get the size of the file. */
        long bufsize = ftell(fp);
        if (bufsize == -1) { /* Error */ }

        /* Allocate our buffer to that size. */
        source = malloc(sizeof(char) * (bufsize + 1));

        /* Go back to the start of the file. */
        if (fseek(fp, 0L, SEEK_SET) != 0) { /* Error */ }

        /* Read the entire file into memory. */
        size_t newLen = fread(source, sizeof(char), bufsize, fp);
        if ( ferror( fp ) != 0 ) {
            fputs("Error reading file", stderr);
        } else {
            source[newLen++] = '\0'; /* Just to be safe. */
        }
    }
    fclose(fp);
}

free(source); /* Don't forget to call free() later! */

¡Sí, probablemente serías arrestado por tu terrible abuso de strcat!

Eche un vistazo a getline(), lee los datos una línea a la vez, pero lo más importante es que puede limitar la cantidad de caracteres que lee, para que no se desborde el búfer.

Strcat es relativamente lento porque tiene que buscar el final en toda la cadena en cada inserción de carácter. Normalmente mantendría un puntero al final actual del almacenamiento de cadenas y lo pasaría a getline como la posición para leer la siguiente línea.

Si está en un sistema Linux, una vez que tenga el descriptor de archivo, puede obtener mucha información sobre el archivo usando fstat()

http://linux.die.net/man/2/stat

así que podrías tener

#include  <unistd.h> 
void main()
{
    struct stat stat;
    int fd;
    //get file descriptor
    fstat(fd, &stat);
    //the size of the file is now in stat.st_size
}

Esto evita buscar el principio y el final del archivo.

Ver este artículo de JoelOnSoftware por qué no quieres usar strcat.

Mirar miedo por una alternativa. Úselo con 1 para el tamaño cuando esté leyendo bytes o caracteres.

¿Por qué no usas la matriz de caracteres que tienes? Esto debería hacerlo:

   source[i] = getc(fp); 
   i++;

No probado, pero debería funcionar. Y sí, podría implementarse mejor con fread, lo dejaré como ejercicio para el lector.

#define DEFAULT_SIZE 100
#define STEP_SIZE 100

char *buffer[DEFAULT_SIZE];
size_t buffer_sz=DEFAULT_SIZE;
size_t i=0;
while(!feof(fp)){
  buffer[i]=fgetc(fp);
  i++;
  if(i>=buffer_sz){
    buffer_sz+=STEP_SIZE;
    void *tmp=buffer;
    buffer=realloc(buffer,buffer_sz);
    if(buffer==null){ free(tmp); exit(1);} //ensure we don't have a memory leak
  }
}
buffer[i]=0;

Creo que quieres pan:

http://www.cplusplus.com/reference/clibrary/cstdio/fread/