Bagaimana cara membaca konten file menjadi string di C?

Apa cara paling sederhana (rawan kesalahan, baris kode paling sedikit, bagaimanapun Anda ingin menafsirkannya) untuk membuka file di C dan membaca isinya menjadi string (char *, char [], apa saja)?

Saya cenderung hanya memuat seluruh buffer sebagai potongan memori mentah ke dalam memori dan melakukan parsing sendiri. Dengan cara itu saya memiliki kendali terbaik atas apa yang dilakukan lib standar pada berbagai platform.

Ini adalah rintisan yang saya gunakan untuk ini. Anda mungkin juga ingin memeriksa kode kesalahan untuk fseek, ftell dan fread. (dihilangkan untuk kejelasan).

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

Solusi lain, sayangnya sangat bergantung pada OS, adalah pemetaan memori file. Manfaat umumnya mencakup kinerja membaca, dan penggunaan memori yang berkurang karena tampilan aplikasi dan cache file sistem operasi sebenarnya dapat berbagi memori fisik.

Kode POSIX akan terlihat seperti ini:

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 di sisi lain sedikit lebih rumit, dan sayangnya saya tidak memiliki kompiler di depan saya untuk diuji, tetapi fungsinya disediakan oleh CreateFileMapping() dan MapViewOfFile().

Jika "membaca isinya menjadi string" berarti file tidak berisi karakter dengan kode 0, Anda juga dapat menggunakan fungsi getdelim (), yang menerima blok memori dan mengalokasikannya kembali jika perlu, atau hanya mengalokasikan seluruh buffer untuk Anda, dan membaca file ke dalamnya hingga menemukan pembatas atau akhir file yang ditentukan. Cukup berikan '\ 0' sebagai pemisah untuk membaca seluruh file.

Fungsi ini tersedia di GNU C Library, http://www.gnu.org/software/libc/manual/html_mono/libc.html#index-getdelim-994

Kode contoh mungkin terlihat sesederhana

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

Jika filenya adalah teks, dan Anda ingin mendapatkan baris demi baris teks, cara termudah adalah dengan menggunakan fgets ().

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

Jika Anda membaca file khusus seperti stdin atau pipa, Anda tidak akan bisa menggunakan fstat untuk mendapatkan ukuran file sebelumnya. Selain itu, jika Anda membaca file biner, widget akan kehilangan informasi ukuran string karena karakter '\ 0' yang disematkan. Cara terbaik untuk membaca file adalah dengan menggunakan read dan 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;
}

Catatan: Ini adalah modifikasi dari jawaban yang diterima di atas.

Berikut cara melakukannya, lengkap dengan pengecekan error.

Saya telah menambahkan pemeriksa ukuran untuk berhenti ketika file lebih besar dari 1 GiB. Saya melakukan ini karena program menempatkan seluruh file ke dalam string yang mungkin menggunakan terlalu banyak ram dan membuat komputer crash. Namun, jika Anda tidak peduli, Anda dapat menghapusnya dari kode.

#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) {
                 free(buffer);
                 *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;
}

Dan untuk memeriksa kesalahan:

int err;
size_t f_size;
char * f_data;

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

if (err) {
    // process error
}
else {
    // process data
    free(f_data);
}

Jika Anda menggunakan glib, maka Anda dapat menggunakan 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);
  }
}

Baru saja diubah dari jawaban yang diterima di atas.

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

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

Ini adalah solusi yang cukup kasar karena tidak ada yang diperiksa terhadap null.

Saya akan menambahkan versi saya sendiri, berdasarkan jawaban di sini, hanya untuk referensi. Kode saya mempertimbangkan sizeof (char) dan menambahkan beberapa komentar padanya.

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

mudah dan rapi (dengan asumsi konten di file kurang dari 10.000):

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