Wie lese ich den Inhalt einer Datei in eine Zeichenfolge in C?

Was ist der einfachste Weg (am wenigsten fehleranfällig, am wenigsten Codezeilen, wie auch immer Sie sie interpretieren möchten), um eine Datei in C zu öffnen und ihren Inhalt in eine Zeichenfolge einzulesen (char *, char [], was auch immer)?

Ich neige dazu, einfach den gesamten Puffer als Rohspeicherblock in den Speicher zu laden und das Parsen selbst durchzuführen. Auf diese Weise habe ich die beste Kontrolle darüber, was die Standardbibliothek auf mehreren Plattformen tut.

Dies ist ein Stummel, den ich dafür benutze. Möglicherweise möchten Sie auch die Fehlercodes für fseek, ftell und fread überprüfen. (aus Gründen der Übersichtlichkeit weggelassen).

char * buffer = 0;
long length;
FILE * f = fopen (filename, "rb");

if (f)
{
  fseek (f, 0, SEEK_END);
  length = ftell (f);
  fseek (f, 0, SEEK_SET);
  buffer = malloc (length);
  if (buffer)
  {
    fread (buffer, 1, length, f);
  }
  fclose (f);
}

if (buffer)
{
  // start to process your data / extract strings here...
}

Eine andere, leider stark vom Betriebssystem abhängige Lösung ist die Speicherzuordnung der Datei. Zu den Vorteilen gehören im Allgemeinen die Leseleistung und die geringere Speichernutzung, da die Anwendungsansicht und der Dateicache des Betriebssystems den physischen Speicher tatsächlich gemeinsam nutzen können.

POSIX-Code würde folgendermaßen aussehen:

int fd = open("filename", O_RDONLY);
int len = lseek(fd, 0, SEEK_END);
void *data = mmap(0, len, PROT_READ, MAP_PRIVATE, fd, 0);

Windows hingegen ist etwas kniffliger, und leider habe ich keinen Compiler zum Testen vor mir, aber die Funktionalität wird von CreateFileMapping()und bereitgestellt MapViewOfFile().

Wenn "Inhalt in eine Zeichenfolge einlesen" bedeutet, dass die Datei keine Zeichen mit dem Code 0 enthält, können Sie auch die Funktion getdelim () verwenden, die entweder einen Speicherblock akzeptiert und ihn bei Bedarf neu zuweist oder nur den gesamten Puffer für zuweist Sie und liest die Datei hinein, bis sie auf ein bestimmtes Trennzeichen oder Dateiende stößt. Übergeben Sie einfach '\ 0' als Trennzeichen, um die gesamte Datei zu lesen.

Diese Funktion ist in der GNU C-Bibliothek unter http://www.gnu.org/software/libc/manual/html_mono/libc.html#index-getdelim-994 verfügbar

Der Beispielcode sieht möglicherweise so einfach aus wie

char* buffer = NULL;
size_t len;
ssize_t bytes_read = getdelim( &buffer, &len, '\0', fp);
if ( bytes_read != -1) {
  /* Success, now the entire file is in the buffer */

Wenn es sich bei der Datei um Text handelt und Sie den Text zeilenweise abrufen möchten, verwenden Sie am einfachsten fgets ().

char buffer[100];
FILE *fp = fopen("filename", "r");                 // do not use "rb"
while (fgets(buffer, sizeof(buffer), fp)) {
... do something
}
fclose(fp);

Wenn Sie spezielle Dateien wie stdin oder eine Pipe lesen, können Sie fstat nicht verwenden, um die Dateigröße im Voraus zu ermitteln. Wenn Sie eine Binärdatei lesen, verlieren fgets aufgrund der eingebetteten '\ 0'-Zeichen die Informationen zur Zeichenfolgengröße. Der beste Weg, eine Datei zu lesen, ist die Verwendung von read und realloc:

#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>

int main () {
    char buf[4096];
    ssize_t n;
    char *str = NULL;
    size_t len = 0;
    while (n = read(STDIN_FILENO, buf, sizeof buf)) {
        if (n < 0) {
            if (errno == EAGAIN)
                continue;
            perror("read");
            break;
        }
        str = realloc(str, len + n + 1);
        memcpy(str + len, buf, n);
        len += n;
        str[len] = '\0';
    }
    printf("%.*s\n", len, str);
    return 0;
}

Hinweis: Dies ist eine Änderung der oben akzeptierten Antwort.

Hier ist eine Möglichkeit, dies zu tun, einschließlich der Fehlerprüfung.

Ich habe eine Größenprüfung hinzugefügt, um zu beenden, wenn die Datei größer als 1 GiB war. Ich habe dies getan, weil das Programm die gesamte Datei in eine Zeichenfolge einfügt, die möglicherweise zu viel RAM verwendet und einen Computer zum Absturz bringt. Wenn Sie sich jedoch nicht darum kümmern, können Sie es einfach aus dem Code entfernen.

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

#define FILE_OK 0
#define FILE_NOT_EXIST 1
#define FILE_TO_LARGE 2
#define FILE_READ_ERROR 3

char * c_read_file(const char * f_name, int * err, size_t * f_size) {
    char * buffer;
    size_t length;
    FILE * f = fopen(f_name, "rb");
    size_t read_length;

    if (f) {
        fseek(f, 0, SEEK_END);
        length = ftell(f);
        fseek(f, 0, SEEK_SET);

        // 1 GiB; best not to load a whole large file in one string
        if (length > 1073741824) {
            *err = FILE_TO_LARGE;

            return NULL;
        }

        buffer = (char *)malloc(length + 1);

        if (length) {
            read_length = fread(buffer, 1, length, f);

            if (length != read_length) {
                 *err = FILE_READ_ERROR;

                 return NULL;
            }
        }

        fclose(f);

        *err = FILE_OK;
        buffer[length] = '\0';
        *f_size = length;
    }
    else {
        *err = FILE_NOT_EXIST;

        return NULL;
    }

    return buffer;
}

Und um nach Fehlern zu suchen:

int err;
size_t f_size;
char * f_data;

f_data = c_read_file("test.txt", &err, &f_size);

if (err) {
    // process error
}

Wenn Sie verwenden glib, können Sie g_file_get_contents verwenden .

gchar *contents;
GError *err = NULL;

g_file_get_contents ("foo.txt", &contents, NULL, &err);
g_assert ((contents == NULL && err != NULL) || (contents != NULL && err == NULL));
if (err != NULL)
  {
    // Report error to user, and free error
    g_assert (contents == NULL);
    fprintf (stderr, "Unable to read file: %s\n", err->message);
    g_error_free (err);
  }
else
  {
    // Use file contents
    g_assert (contents != NULL);
  }
}

// Assumes the file exists and will seg. fault otherwise.
const GLchar *load_shader_source(char *filename) {
  FILE *file = fopen(filename, "r");             // open 
  fseek(file, 0L, SEEK_END);                     // find the end
  size_t size = ftell(file);                     // get the size in bytes
  GLchar *shaderSource = calloc(1, size);        // allocate enough bytes
  rewind(file);                                  // go back to file beginning
  fread(shaderSource, size, sizeof(char), file); // read each char into ourblock
  fclose(file);                                  // close the stream
  return shaderSource;
}

Dies ist eine ziemlich grobe Lösung, da nichts gegen Null geprüft wird.

Nur geändert von der oben akzeptierten Antwort.

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

char *readFile(char *filename) {
    FILE *f = fopen(filename, "rt");
    assert(f);
    fseek(f, 0, SEEK_END);
    long length = ftell(f);
    fseek(f, 0, SEEK_SET);
    char *buffer = (char *) malloc(length + 1);
    buffer[length] = '\0';
    fread(buffer, 1, length, f);
    fclose(f);
    return buffer;
}

int main() {
    char *content = readFile("../hello.txt");
    printf("%s", content);
}

Ich werde meine eigene Version hinzufügen, basierend auf den Antworten hier, nur als Referenz. Mein Code berücksichtigt sizeof (char) und fügt einige Kommentare hinzu.

// Open the file in read mode.
FILE *file = fopen(file_name, "r");
// Check if there was an error.
if (file == NULL) {
    fprintf(stderr, "Error: Can't open file '%s'.", file_name);
    exit(EXIT_FAILURE);
}
// Get the file length
fseek(file, 0, SEEK_END);
long length = ftell(file);
fseek(file, 0, SEEK_SET);
// Create the string for the file contents.
char *buffer = malloc(sizeof(char) * (length + 1));
buffer[length] = '\0';
// Set the contents of the string.
fread(buffer, sizeof(char), length, file);
// Close the file.
fclose(file);
// Do something with the data.
// ...
// Free the allocated string space.
free(buffer);

einfach und ordentlich (vorausgesetzt, der Inhalt der Datei beträgt weniger als 10000):

void read_whole_file(char fileName[1000], char buffer[10000])
{
    FILE * file = fopen(fileName, "r");
    if(file == NULL)
    {
        puts("File not found");
        exit(1);
    }
    char  c;
    int idx=0;
    while (fscanf(file , "%c" ,&c) == 1)
    {
        buffer[idx] = c;
        idx++;
    }
    buffer[idx] = 0;
}