সি এর স্ট্রিং এ কোনও ফাইলের সামগ্রী কীভাবে পড়বেন?

Question 1

সিতে কোনও ফাইল খুলতে এবং এর বিষয়বস্তুগুলিকে স্ট্রিংয়ে পড়তে (চর *, চর [], যাই হোক না কেন) সবচেয়ে সহজ উপায় (কমপক্ষে ত্রুটি-প্রবণ, কোডের ন্যূনতম লাইনগুলি, তবে আপনি এটি ব্যাখ্যা করতে চান) কী?

Question 2

আমি কেবল কাঁচা স্মৃতি মেমরির অংশ হিসাবে পুরো বাফারটি লোড করি এবং নিজেই বিশ্লেষণ করি। একাধিক প্ল্যাটফর্মে স্ট্যান্ডার্ড লিব কী করে তার উপর আমার সর্বোত্তম নিয়ন্ত্রণ রয়েছে।

এটি আমি এটির জন্য ব্যবহার করছি ub আপনি 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

অন্যটি, দুর্ভাগ্যক্রমে উচ্চ ওএস-নির্ভর, সমাধান হ'ল মেমরি ম্যাপিং। সুবিধার মধ্যে সাধারণত পড়ার পারফরম্যান্স অন্তর্ভুক্ত থাকে এবং অ্যাপ্লিকেশন ভিউ এবং অপারেটিং সিস্টেমগুলির ফাইল ফাইল ক্যাশে প্রকৃতপক্ষে শারীরিক স্মৃতি ভাগ করতে পারে বলে মেমরির ব্যবহার হ্রাস পায়।

পসিক্স কোডটি এর মতো দেখায়:

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 সহ অক্ষর নেই, আপনি গেটডেলিম () ফাংশনটিও ব্যবহার করতে পারেন, যা হয় মেমরির একটি ব্লক গ্রহণ করে এবং প্রয়োজনে এটি পুনরায় স্থানান্তর করে, বা কেবলমাত্র পুরো বাফারটির জন্য বরাদ্দ করে আপনি, এবং এটিতে ফাইলটি পড়েন যতক্ষণ না এটি নির্দিষ্ট সীমাবদ্ধ বা ফাইলটির শেষের মুখোমুখি হয়। পুরো ফাইলটি পড়ার জন্য সীমাবদ্ধ হিসাবে কেবল '\ 0' পাস করুন।

এই ফাংশনটি জিএনইউ সি লাইব্রেরিতে, 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

ফাইলটি যদি পাঠ্য হয় এবং আপনি পাঠ্য লাইনটি লাইন পেতে চান তবে সবচেয়ে সহজ উপায় হ'ল fgets () ব্যবহার করা।

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

Question 6

আপনি যদি স্টিডিন বা পাইপের মতো বিশেষ ফাইলগুলি পড়ছেন তবে আপনি ফাইলের আকার আগেই পেতে fstat ব্যবহার করতে সক্ষম হবেন না। এছাড়াও, আপনি যদি বাইনারি ফাইল পড়ে থাকেন তবে এম্বেডড '\ 0' অক্ষরের কারণে স্ট্রিং আকারের তথ্য হারাতে চলেছে। তারপরে কোনও ফাইল পড়ার সর্বোত্তম উপায় হ'ল পঠন এবং পুনর্নির্মাণ ব্যবহার:

#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

দ্রষ্টব্য: এটি উপরে গৃহীত উত্তরের একটি পরিবর্তন।

এটি করার একটি উপায় এখানে, ত্রুটি পরীক্ষা করে সম্পূর্ণ complete

ফাইলটি যখন 1 জিআইবির চেয়ে বড় ছিল তখন আমি প্রস্থান করতে একটি আকারের পরীক্ষক যুক্ত করেছি। আমি এটি করেছি কারণ প্রোগ্রামটি পুরো ফাইলটিকে একটি স্ট্রিংয়ে রাখে যা খুব বেশি র‌্যাম ব্যবহার করে এবং কম্পিউটার ক্র্যাশ করতে পারে। তবে, যদি আপনি এটির যত্ন না পান তবে আপনি কেবল কোড থেকে এটিকে সরাতে পারেন।

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

এবং ত্রুটিগুলি যাচাই করতে:

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

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

উপরের স্বীকৃত উত্তর থেকে সবেমাত্র পরিবর্তিত।

#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 10

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