C-Programmierung: Wie man den gesamten Dateiinhalt in einen Puffer einliest [duplicate]

Question 1

Ich möchte den gesamten Inhalt einer Datei in einen Puffer schreiben. Die Datei enthält eigentlich nur einen String, den ich mit einem String vergleichen muss.

Was wäre die effizienteste Option, die auch unter Linux portabel ist.

ENV: Windows

Question 2

Die Portierbarkeit zwischen Linux und Windows ist ein großes Problem, da Linux ein POSIX-konformes System mit – im Allgemeinen – einer richtigen, hochwertigen Toolchain für C ist, während Windows nicht einmal viele Funktionen in der C-Standardbibliothek bereitstellt.

Wenn Sie sich jedoch an den Standard halten möchten, können Sie Folgendes schreiben:

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

FILE *f = fopen("textfile.txt", "rb");
fseek(f, 0, SEEK_END);
long fsize = ftell(f);
fseek(f, 0, SEEK_SET);  /* same as rewind(f); */

char *string = malloc(fsize + 1);
fread(string, fsize, 1, f);
fclose(f);

string[fsize] = 0;

Hier string enthält den Inhalt der Textdatei als ordnungsgemäß mit 0 abgeschlossenen C-String. Dieser Code ist nur Standard-C, er ist nicht POSIX-spezifisch (obwohl er nicht garantiert, dass er unter Windows funktioniert/kompiliert wird …)

Question 3

Hier ist, was ich empfehlen würde.

Es sollte C89-konform und vollständig portabel sein. Insbesondere funktioniert es auch auf Pipes und Sockets auf POSIXy-Systemen.

Die Idee ist, dass wir die Eingabe in großen Stücken lesen (READALL_CHUNK), den Puffer dynamisch nach Bedarf neu zuordnen. Wir verwenden nur realloc(), fread(), ferror()und free():

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

/* Size of each input chunk to be
   read and allocate for. */
#ifndef  READALL_CHUNK
#define  READALL_CHUNK  262144
#endif

#define  READALL_OK          0  /* Success */
#define  READALL_INVALID    -1  /* Invalid parameters */
#define  READALL_ERROR      -2  /* Stream error */
#define  READALL_TOOMUCH    -3  /* Too much input */
#define  READALL_NOMEM      -4  /* Out of memory */

/* This function returns one of the READALL_ constants above.
   If the return value is zero == READALL_OK, then:
     (*dataptr) points to a dynamically allocated buffer, with
     (*sizeptr) chars read from the file.
     The buffer is allocated for one extra char, which is NUL,
     and automatically appended after the data.
   Initial values of (*dataptr) and (*sizeptr) are ignored.
*/
int readall(FILE *in, char **dataptr, size_t *sizeptr)
{
    char  *data = NULL, *temp;
    size_t size = 0;
    size_t used = 0;
    size_t n;

    /* None of the parameters can be NULL. */
    if (in == NULL || dataptr == NULL || sizeptr == NULL)
        return READALL_INVALID;

    /* A read error already occurred? */
    if (ferror(in))
        return READALL_ERROR;

    while (1) {

        if (used + READALL_CHUNK + 1 > size) {
            size = used + READALL_CHUNK + 1;

            /* Overflow check. Some ANSI C compilers
               may optimize this away, though. */
            if (size <= used) {
                free(data);
                return READALL_TOOMUCH;
            }

            temp = realloc(data, size);
            if (temp == NULL) {
                free(data);
                return READALL_NOMEM;
            }
            data = temp;
        }

        n = fread(data + used, 1, READALL_CHUNK, in);
        if (n == 0)
            break;

        used += n;
    }

    if (ferror(in)) {
        free(data);
        return READALL_ERROR;
    }

    temp = realloc(data, used + 1);
    if (temp == NULL) {
        free(data);
        return READALL_NOMEM;
    }
    data = temp;
    data[used] = '\0';

    *dataptr = data;
    *sizeptr = used;

    return READALL_OK;
}

Oben habe ich eine konstante Chunk-Größe verwendet, READALL_CHUNK == 262144 (256*1024). Das bedeutet, dass im schlimmsten Fall bis zu 262145 Zeichen verschwendet werden (allokiert, aber nicht verwendet), aber nur vorübergehend. Am Ende weist die Funktion den Puffer auf die optimale Größe neu zu. Das bedeutet auch, dass wir vier Neuzuweisungen pro Megabyte gelesener Daten vornehmen.

Der Standardwert von 262144 Byte im obigen Code ist ein konservativer Wert; Es funktioniert gut für sogar alte Minilaptops und Raspberry Pis und die meisten eingebetteten Geräte mit mindestens einigen Megabyte RAM, die für den Prozess verfügbar sind. Es ist jedoch nicht so klein, dass es die Operation (aufgrund vieler Leseaufrufe und vieler Pufferneuzuweisungen) auf den meisten Systemen verlangsamt.

Für Desktop-Rechner zu diesem Zeitpunkt (2017) empfehle ich einen viel größeren READALL_CHUNKvielleicht #define READALL_CHUNK 2097152 (2 MiB).

Denn die Definition von READALL_CHUNK geschützt ist (d. h. es ist nur definiert, wenn es zu diesem Zeitpunkt im Code noch undefiniert ist), können Sie den Standardwert zur Kompilierzeit überschreiben, indem Sie (in den meisten C-Compilern) verwenden -DREADALL_CHUNK=2097152 Befehlszeilenoption — aber überprüfen Sie Ihre Compileroptionen für die Definition eines Präprozessormakros mit Befehlszeilenoptionen.

Question 4

Eine tragbare Lösung könnte verwendet werden getc.

#include <stdio.h>

char buffer[MAX_FILE_SIZE];
size_t i;

for (i = 0; i < MAX_FILE_SIZE; ++i)
{
    int c = getc(fp);

    if (c == EOF)
    {
        buffer[i] = 0x00;
        break;
    }

    buffer[i] = c;
}

Wenn Sie keine haben möchten MAX_FILE_SIZE Makro oder wenn es sich um eine große Zahl handelt (z buffer wäre zu groß, um auf den Stapel zu passen), verwenden Sie die dynamische Zuordnung.