C में स्ट्रिंग के लिए फ़ाइल की सामग्री कैसे पढ़ें?

Question 1

C में किसी फ़ाइल को खोलने और उसकी सामग्री को स्ट्रिंग (char *, char [], जो भी हो) में पढ़ने के लिए सबसे सरल तरीका (कम से कम त्रुटि-रहित, कम से कम कोड की लाइनें, हालाँकि आप इसकी व्याख्या करना चाहते हैं) क्या है?

Question 2

मैं बस पूरे बफर को एक कच्चे मेमोरी चंक के रूप में मेमोरी में लोड करता हूं और पार्सिंग अपने आप करता हूं। इस तरह से कई प्लेटफ़ॉर्मों पर मानक लीबी क्या करती है, इस पर मेरा सबसे अच्छा नियंत्रण है।

यह एक स्टब है जो मैं इसके लिए उपयोग करता हूं। आप fseek, ftell और fread के लिए त्रुटि-कोड की जांच करना चाहते हैं। (स्पष्टता के लिए छोड़ा गया)।

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

Question 3

एक और, दुर्भाग्य से अत्यधिक ओएस पर निर्भर, समाधान मेमोरी मैपिंग फ़ाइल है। लाभ में आम तौर पर रीड का प्रदर्शन शामिल होता है, और कम किए गए मेमोरी का उपयोग अनुप्रयोगों के रूप में होता है और ऑपरेटिंग सिस्टम फ़ाइल कैश वास्तव में भौतिक मेमोरी साझा कर सकते हैं।

POSIX कोड इस तरह दिखेगा:

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

दूसरी ओर विंडोज थोड़ा अधिक मुश्किल है, और दुर्भाग्य से मेरे पास परीक्षण करने के लिए मेरे सामने संकलक नहीं है, लेकिन कार्यक्षमता CreateFileMapping()और द्वारा प्रदान की जाती है MapViewOfFile()।

Question 4

यदि "इसकी सामग्री को एक स्ट्रिंग में पढ़ें" का अर्थ है कि फ़ाइल में कोड 0 के साथ वर्ण नहीं हैं, तो आप getdelim () फ़ंक्शन का भी उपयोग कर सकते हैं, जो या तो मेमोरी के एक ब्लॉक को स्वीकार करता है और यदि आवश्यक हो, तो उसे पुन: आवंटित करता है, या बस पूरे बफर को आवंटित करता है जब तक यह एक निर्दिष्ट सीमांकक या फ़ाइल के अंत का सामना नहीं करता है, तब तक आप उसमें फ़ाइल को पढ़ते हैं। पूरी फ़ाइल पढ़ने के लिए सीमांकक के रूप में बस '\ 0' पास करें।

यह फ़ंक्शन GNU C लाइब्रेरी, http://www.gnu.org/software/libc/manual/html_mono/libc.html#index-getdelim-994 पर उपलब्ध है

नमूना कोड जितना सरल हो सकता है

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

Question 5

यदि फ़ाइल पाठ है, और आप टेक्स्ट लाइन को लाइन से प्राप्त करना चाहते हैं, तो सबसे आसान तरीका है फ़्यूज़ () का उपयोग करना।

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

Question 6

यदि आप स्टडिन या पाइप जैसी विशेष फाइलें पढ़ रहे हैं, तो आप फ़ाइल का आकार पहले से प्राप्त करने के लिए फस्टैट का उपयोग करने में सक्षम नहीं होंगे। इसके अलावा, यदि आप एक बाइनरी फ़ाइल पढ़ रहे हैं तो एम्बेडेड '\' वर्णों के कारण स्ट्रिंग आकार की जानकारी खोना है। किसी फ़ाइल को पढ़ने का सबसे अच्छा तरीका है रीड और रियललोक का उपयोग करना:

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

Question 7

नोट: यह ऊपर दिए गए स्वीकृत उत्तर का एक संशोधन है।

यहाँ यह करने का एक तरीका है, त्रुटि जाँच के साथ पूरा।

जब फ़ाइल 1 GiB से बड़ी थी, तब मैंने छोड़ने के लिए एक आकार चेकर जोड़ा है। मैंने ऐसा इसलिए किया क्योंकि प्रोग्राम पूरी फाइल को एक स्ट्रिंग में रखता है जो बहुत अधिक रैम का उपयोग कर सकता है और कंप्यूटर को क्रैश कर सकता है। हालाँकि, अगर आपको इस बात की परवाह नहीं है कि आप इसे कोड से हटा सकते हैं।

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

और त्रुटियों की जाँच करने के लिए:

int err;
size_t f_size;
char * f_data;

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

if (err) {
    // process error
}

Question 8

यदि आप उपयोग कर रहे हैं glib, तो आप 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);
  }
}

Question 9

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

यह एक बहुत ही क्रूड समाधान है क्योंकि अशक्त के खिलाफ कुछ भी नहीं जांचा जाता है।

Question 10

बस ऊपर दिए गए स्वीकृत उत्तर से संशोधित किया गया है।

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

Question 11

मैं अपने स्वयं के संस्करण को जोड़ दूंगा, यहां जवाबों के आधार पर, केवल संदर्भ के लिए। मेरा कोड आकार (चार) को ध्यान में रखता है और इसमें कुछ टिप्पणियां जोड़ता है।

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

Question 12

आसान और साफ सुथरा (फ़ाइल में सामग्री 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;
}