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

J'ai tendance à charger la totalité de la mémoire tampon brut pour mémoire morceau dans la mémoire et faire l'analyse de mon propre chef. De cette façon, j'ai un meilleur contrôle sur ce que la lib standard ne sur de multiples plateformes.

C'est un stub-je utiliser pour cela. vous pouvez également vérifier l'erreur-codes 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...
}

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

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

L'exemple de code pourrait ressembler aussi simple que

char* buffer = NULL;
size_t len;
ssize_t bytes_read = getdelim( &buffer, &len, '
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 */
', fp);
if ( bytes_read != -1) {
  /* Success, now the entire file is in the buffer */

Si vous êtes la lecture de fichiers spéciaux comme stdin ou un tuyau, vous n'allez pas être en mesure d'utiliser fstat pour obtenir la taille du fichier au préalable. Aussi, si vous êtes à la lecture d'un fichier binaire fgets va perdre la taille de la chaîne de l'information en raison de l'embedded caractères '\0'. Meilleur moyen de lire un fichier est alors d'utiliser la lecture 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] = '
#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;
}
';
    }
    printf("%.*s\n", len, str);
    return 0;
}

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

Voici une façon de le faire, complet avec contrôle d'erreur.

J'ai ajouté une taille de checker pour arrêter de fumer quand le fichier est plus grand que 1 GiB. J'ai fait cette parce que le programme met l'intégralité du fichier en une chaîne de caractères qui peuvent utiliser trop de mémoire vive et de crash d'un ordinateur. Toutefois, si vous ne se soucient pas que vous pouvez simplement le supprimer à partir 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 hole 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] = '
#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 hole 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;
}
';
        *f_size = length;
    }
    else {
        *err = FILE_NOT_EXIST;

        return NULL;
    }

    return buffer;
}

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

Juste modifié à partir de la accepté la réponse 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] = '
#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);
}
';
    fread(buffer, 1, length, f);
    fclose(f);
    return buffer;
}

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