Comment lire le contenu d'un fichier dans une chaîne en C?

Quel est le moyen le plus simple (le moins sujet aux erreurs, le moins de lignes de code, quelle que soit la manière dont vous voulez l'interpréter) pour ouvrir un fichier en C et lire son contenu dans une chaîne (char *, char [], peu importe)?

J'ai tendance à charger tout le tampon en tant que bloc de mémoire brute dans la mémoire et à faire l'analyse par moi-même. De cette façon, j'ai le meilleur contrôle sur ce que fait la bibliothèque standard sur plusieurs plates-formes.

C'est un talon que j'utilise pour cela. vous pouvez également vérifier les codes d'erreur pour fseek, ftell et fread. (omis pour plus de clarté).

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

Une autre solution, malheureusement très dépendante du système d'exploitation, consiste à mapper le fichier en mémoire. Les avantages comprennent généralement les performances de lecture et une utilisation réduite de la mémoire, car la vue des applications et le cache des fichiers du système d'exploitation peuvent en fait partager la mémoire physique.

Le code POSIX ressemblerait à ceci:

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 en revanche est un peu plus délicat, et malheureusement je n'ai pas de compilateur devant moi à tester, mais la fonctionnalité est fournie par CreateFileMapping()et MapViewOfFile().

Si "lire son contenu dans une chaîne" signifie que le fichier ne contient pas de caractères avec le code 0, vous pouvez également utiliser la fonction getdelim (), qui accepte un bloc de mémoire et le réalloue si nécessaire, ou alloue simplement le tampon entier pour vous, et y lit le fichier jusqu'à ce qu'il rencontre un délimiteur ou une fin de fichier spécifié. Passez simplement '\ 0' comme délimiteur pour lire le fichier entier.

Cette fonction est disponible dans la bibliothèque GNU C, http://www.gnu.org/software/libc/manual/html_mono/libc.html#index-getdelim-994

L'exemple de code peut sembler aussi simple que

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

Si le fichier est du texte et que vous souhaitez obtenir le texte ligne par ligne, le moyen le plus simple est d'utiliser fgets ().

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

Si vous lisez des fichiers spéciaux comme stdin ou un tube, vous ne pourrez pas utiliser fstat pour obtenir la taille du fichier au préalable. De plus, si vous lisez un fichier binaire, fgets perdra les informations de taille de chaîne à cause des caractères '\ 0' incorporés. La meilleure façon de lire un fichier est alors d'utiliser read et 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;
}

Remarque: Ceci est une modification de la réponse acceptée ci-dessus.

Voici un moyen de le faire, avec une vérification des erreurs.

J'ai ajouté un vérificateur de taille pour quitter lorsque le fichier était supérieur à 1 Gio. J'ai fait cela parce que le programme met le fichier entier dans une chaîne qui peut utiliser trop de RAM et faire planter un ordinateur. Cependant, si cela ne vous intéresse pas, vous pouvez simplement le supprimer du code.

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

Et pour vérifier les erreurs:

int err;
size_t f_size;
char * f_data;

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

if (err) {
    // process error
}

Si vous utilisez glib, vous pouvez utiliser g_file_get_contents ;

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

C'est une solution assez grossière car rien n'est vérifié par rapport à null.

Juste modifié de la réponse acceptée ci-dessus.

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

J'ajouterai ma propre version, basée sur les réponses ici, juste pour référence. Mon code prend en compte sizeof (char) et y ajoute quelques commentaires.

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

facile et soigné (en supposant que le contenu du fichier est inférieur à 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;
}