Korrekte Methode zum Einlesen einer Textdatei in einen Puffer in C? [duplicate]

Ich habe es mit kleinen Textdateien zu tun, die ich in einen Puffer einlesen möchte, während ich sie verarbeite, also habe ich mir den folgenden Code ausgedacht:

...
char source[1000000];

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

Ist dies der richtige Weg, den Inhalt der Datei in den Puffer zu legen, oder missbrauche ich strcat()?

Ich iteriere dann so durch den Puffer:

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);
}

An diesem Code ist einiges falsch:

1. Es ist sehr langsam (Sie extrahieren den Puffer Zeichen für Zeichen).
2. Wenn die Dateigröße überschritten ist sizeof(source)ist dies anfällig für Pufferüberläufe.
3. Wirklich, wenn Sie es genauer betrachten, sollte dieser Code überhaupt nicht funktionieren. Wie in den Manpages angegeben:

Das strcat() Die Funktion hängt eine Kopie des nullterminierten Strings s2 an das Ende des nullterminierten Strings s1 und fügt dann ein abschließendes `\0′ hinzu.

Sie hängen ein Zeichen (keine NUL-terminierte Zeichenfolge!) An eine Zeichenfolge an, die NUL-terminiert sein kann oder nicht. Das nur Zeitweise kann ich mir vorstellen, dass dies gemäß der Manpage-Beschreibung funktioniert, wenn jedes Zeichen in der Datei NUL-terminiert ist, in diesem Fall wäre dies ziemlich sinnlos. Also ja, das ist definitiv ein schrecklicher Missbrauch von strcat().

Im Folgenden finden Sie zwei Alternativen, die Sie stattdessen verwenden sollten.

Wenn Sie die maximale Puffergröße im Voraus kennen:

#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);
}

Oder, falls nicht:

#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! */

Ja – Sie würden wahrscheinlich wegen Ihres schrecklichen Missbrauchs von strcat verhaftet werden!

Schauen Sie sich getline() an, es liest die Daten zeilenweise, aber vor allem kann es die Anzahl der gelesenen Zeichen begrenzen, damit der Puffer nicht überläuft.

Strcat ist relativ langsam, weil es bei jeder Zeicheneinfügung den gesamten String nach dem Ende durchsuchen muss. Normalerweise würden Sie einen Zeiger auf das aktuelle Ende des Zeichenfolgenspeichers behalten und diesen an getline als Position übergeben, an der die nächste Zeile gelesen werden soll.

Wenn Sie sich auf einem Linux-System befinden, können Sie mit fstat() viele Informationen über die Datei erhalten, sobald Sie den Dateideskriptor haben.

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

also hast du vielleicht

#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
}

Dadurch wird vermieden, bis zum Anfang und Ende der Datei zu suchen.

Sehen diesen Artikel von JoelOnSoftware warum Sie nicht verwenden möchten strcat.

Ansehen Angst für eine Alternative. Verwenden Sie es mit 1 für die Größe, wenn Sie Bytes oder Zeichen lesen.

Warum verwendest du nicht einfach das Array von Zeichen, das du hast? Das sollte es tun:

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

Nicht getestet, sollte aber funktionieren.. Und ja, es könnte mit fread besser umgesetzt werden, das überlasse ich dem Leser als Übung.

#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;

Ich denke, du willst Angst haben:

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