String (Line) I/O in Files in c in hindi |Low-Level File i/o in c in hindi

Low-Level File i/o in c in hindi

String (Line) I/O in Files in c in hindi

कई उद्देश्यों के लिए, character I/O वही है जो आवश्यक है। हालाँकि, कुछ स्थितियों में, संपूर्ण स्ट्रिंग्स को पढ़ने या लिखने वाले फ़ंक्शंस का उपयोग अधिक कुशल हो सकता है। यहां एक प्रोग्राम है जो fputs() का उपयोग करके फ़ाइल में स्ट्रिंग लिखता है और फिर fgets() का उपयोग करके उन्हें वापस पढ़ता है।

/* Receives strings from keyboard and writes them to file "/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
  FILE "fp;
  char s[80];
  fp = fopen("POEM.TXT", "w");
  if(fp = NULL)
{
    puts ("Cannot open file"); exit(1);
  }
printf("\nEnter a few lines of text:\n"); while (strien (gets (s)) > 0)
{
   fputs (s, fp); fputs ("\n", fp);
}
fclose(fp);

/* read the file back */
printf ("\nFile contents are being read now..\n", s);
fp = fopen("POEM TXT", "r");
if (fp == NULL)
{
   puts ("Cannot open file"); exit. (2);
}
while (fgets (5, 79, fp) = NULL) printf("%s",s);

fclose(fp);

Return 0;
}

और यहाँ प्रोग्राम का एक सैंपल है।

Enter a few of text:
Shining and bright, they are forever,
so true about diamonds,
more so of memories,
especially yours!

File contents are being read now...
Shining and bright, they are forever,
so true about diamonds,
more so of memories,
especially yours!

एक्सीक्यूट के दौरान, प्रत्येक स्ट्रिंग दर्ज करने के बाद एंटर दबाएं। लूप के एक्सीक्यूट को समाप्त करने के लिए, एक पंक्ति की शुरुआत में एंटर दबाएं। यह शून्य लंबाई की एक स्ट्रिंग बनाता है, जिसे प्रोग्राम लूप को समाप्त करने के लिए सिग्नल के रूप में पहचानता है।

हमने एक स्ट्रिंग प्राप्त करने के लिए एक वर्ण सरणी स्थापित की है; fputs () फ़ंक्शन इस सरणी की सामग्री को फ़ाइल में लिखता है। चूंकि fputs () स्वचालित रूप से स्ट्रिंग के अंत में एक न्यूलाइन वर्ण नहीं जोड़ता है, हमें फ़ाइल से स्ट्रिंग को वापस पढ़ने में आसान बनाने के लिए इसे स्पष्ट रूप से करना चाहिए।

फ़ाइल को पढ़ते समय, फ़ंक्शन fgets() तीन तर्क लेता है। पहला वह पता है जहां स्ट्रिंग संग्रहीत है, और दूसरा स्ट्रिंग की अधिकतम लंबाई है। यह तर्क fgets () को बहुत लंबे स्ट्रिंग में पढ़ने और सरणी को ओवरफ्लो करने से रोकता है। तीसरा तर्क, FILE संरचना का सूचक है। फ़ाइल से एक पंक्ति पढ़ने पर, स्ट्रिंग s में पंक्ति सामग्री एक ‘\n’ और उसके बाद एक 10′ होगी। इस प्रकार स्ट्रिंग को fgets () द्वारा समाप्त किया जाता है और हमें इसे समाप्त करने की आवश्यकता नहीं होती है जब फ़ाइल की सभी पंक्तियों को पढ़ लिया जाता है, तो हम एक और पंक्ति को पढ़ने का प्रयास करते हैं, जिस स्थिति में fgets () एक NULL देता है।

टेक्स्ट फ़ाइलें और बाइनरी फ़ाइलें

इस अध्याय में हमने अब तक जितने भी प्रोग्राम लिखे हैं, वे सभी टेक्स्ट फाइलों पर काम करते हैं। एक टेक्स्ट फ़ाइल में केवल अक्षर, अंक और विशेष प्रतीकों जैसी पाठ्य जानकारी होती है। टेक्स्ट फ़ाइल का एक अच्छा उदाहरण कोई सी प्रोग्राम है, PR1.C कहें।

इसके विपरीत, एक बाइनरी फ़ाइल केवल बाइट्स का संग्रह है। यह संग्रह C प्रोग्राम (जैसे PR1.EXE) का संकलित संस्करण हो सकता है, या MP4 फ़ाइल में संग्रहीत संगीत डेटा या JPG फ़ाइल में संग्रहीत चित्र हो सकता है।

यह पता लगाने का एक बहुत आसान तरीका है कि कोई फ़ाइल टेक्स्ट फ़ाइल है या बाइनरी फ़ाइल है, उस फ़ाइल को नोटपैड में खोलना है। यदि फ़ाइल खोलने पर आप प्रदर्शित कर सकते हैं कि क्या प्रदर्शित होता है तो यह एक टेक्स्ट फ़ाइल है, अन्यथा यह एक बाइनरी फ़ाइल है।

प्रोग्रामिंग कोण से दो मुख्य क्षेत्र हैं जहां टेक्स्ट और बाइनरी मोड फ़ाइलें अलग हैं। इनकी चर्चा नीचे की गई है।

टेक्स्ट बनाम बाइनरी मोड: न्यूलाइन्स

टेक्स्ट मोड में, फ़ाइल में लिखे जाने से पहले एक न्यूलाइन कैरेक्टर कैरिज रिटर्न लाइनफीड संयोजन में परिवर्तित हो जाता है। इसी तरह, फ़ाइल में कैरिज रिटर्न-लाइनफीड संयोजन फ़ाइल को वापस पढ़ने पर वापस एक नई लाइन में परिवर्तित हो जाता है। यदि कोई फ़ाइल बाइनरी मोड में खोली जाती है, तो ये रूपांतरण नहीं होते हैं।

टेक्स्ट बनाम बाइनरी मोड: नंबरों का संग्रहण

fprintf () का उपयोग करते समय, संख्याओं को वर्ण स्ट्रिंग के रूप में संग्रहीत किया जाता है। इस प्रकार, पूर्णांक 12579 मेमोरी में 4 बाइट्स रखता है, लेकिन जब fprintf() का उपयोग करके फ़ाइल में लिखा जाता है, तो यह प्रति वर्ण 5 बाइट्स, 1 बाइट पर कब्जा कर लेता है। इसी तरह, फ्लोटिंग पॉइंट नंबर 1234.56 फाइल में 7 बाइट्स पर कब्जा कर लेगा। इस प्रकार, अधिक अंकों वाली संख्याओं के लिए अधिक संग्रहण स्थान की आवश्यकता होगी।

इसलिए यदि किसी डिस्क फ़ाइल में बड़ी मात्रा में संख्यात्मक डेटा संग्रहीत किया जाना है, तो टेक्स्ट मोड का उपयोग करना अक्षम हो सकता है। समाधान फ़ाइल को बाइनरी मोड में खोलना और फ़ंक्शन fread() और fwrite() का उपयोग करना है जो बाइनरी प्रारूप में संख्याओं के साथ काम करते हैं। नतीजतन, प्रत्येक संख्या डिस्क पर उतनी ही बाइट्स पर कब्जा कर लेती है जितनी मेमोरी में रहती है।

फाइलों में रिकॉर्ड I/O

मान लीजिए कि हम फ़ाइल से/से कर्मचारियों के बारे में डेटा का I/O प्रदर्शन करना चाहते हैं। इसके लिए हमें एक स्ट्रक्चर कर्मचारी बनाना होगा और फिर कर्मचारी डेटा को फाइल से पढ़ने/लिखने के लिए निम्नलिखित कार्यों का उपयोग करना होगा।

फ़ाइल टेक्स्ट मोड में खोली गई – fscanf () / fprintf ()
फ़ाइल बाइनरी मोड-फ़्रेड () / fwrite () में खोली गई।

नीचे दिया गया कोड स्निपेट है जो दिखाता है कि इन कार्यों का उपयोग कैसे करें आप टिप्पणियों को वास्तविक कोड से बदल सकते हैं ताकि इसे पूरी तरह से काम करने योग्य प्रोग्राम बनाया जा सके,

/*writes /Reads records to /from a film in text /binary mode*/

#include <stdio.h>
  int main()
{
   FILE *fp;
   struct emp
   {
     Char name[40]; int age; float bs;
};
Struct emp e;
fp = fopen("EMPLOYEE.DAT", "W");

/*run a loop to repeat following statements */
/* add code read a record from keyboard into e */
/*write record to file*/
fprintf(fp,"%s %d %f\n", e.name, e.age, e.bs);
fclose(fp);

fp = fopen ("EMPLOYEE.DAT", "r");
/*read records*/
while (fscanf( fp, "%s %d %f", e.name, &e.age, &e.bs) !=EOF)
Printf("%s %d %f\n",e.name, e.age, e.bs);
fclose (fp);

fp= fopen("EMP.DAT", "wb");
/*run a loop to repeat following statements */
/*add code read a record from keyboard into*/
/*write record to file */
fwrite(&e, sizeof(e),1, fp);
fclose(fp);

fp=fopen("EMP.DAT", "rb");
while (fread(&e, sizeof(e), 1, fp)==1)
   Printf("%s %d %f\n",e.name, e.age, e.bs);
fclose (fp);
return 0;
}

ध्यान दें कि हमने बाइनरी फ़ाइल ‘EMP.DAT‘ को “rb” और “wb” मोड में खोला है। फ़ाइल को टेक्स्ट मोड में खोलते समय हम या तो “r” या “का उपयोग कर सकते हैं, लेकिन चूंकि टेक्स्ट मोड डिफ़ॉल्ट मोड है, इसलिए हम आमतौर पर ‘ टी’।

टेक्स्ट मोड फ़ाइल में रिकॉर्ड पढ़ने/लिखने के लिए हमने क्रमशः fscanf() और fprintf() का उपयोग किया है। वे स्कैनफ () और प्रिंटफ () के समान काम करते हैं, सिवाय इसके कि उनके पास एक अतिरिक्त पहला तर्क fp है। यह तर्क उस फ़ाइल को इंगित करता है जिस पर उन्हें काम करना चाहिए।

बाइनरी मोड फ़ाइल में रिकॉर्ड पढ़ने/लिखने के लिए हमने क्रमशः fread() और fwrite() का उपयोग किया है। आइए निम्नलिखित कॉल को समझें:

fwrite(&e, sizeof (e), 1, fp);

मान लीजिए ई का पता 400 है और ई का आकार 48 बाइट्स है। तो उपरोक्त कॉल का अर्थ है- पता 400 से शुरू होकर, अगले 48 बाइट्स को एक बार fp द्वारा इंगित फ़ाइल में लिखें।

इसी तरह कॉल,

fwrite (&e, sizeof (e), 1,fp);

इसका मतलब होगा- fp द्वारा इंगित फ़ाइल से, एक बार पढ़ें, 48 बाइट्स और उन्हें 400 से शुरू होने वाले पते पर संग्रहीत करें।

टेक्स्ट फ़ाइल आधारित रिकॉर्ड i/o के दो नुकसान हैं:

(ए) संख्या अधिक संख्या में बाइट्स पर कब्जा कर लेगी, क्योंकि प्रत्येक संख्या को एक वर्ण स्ट्रिंग के रूप में संग्रहीत किया जाता है:

(बी) यदि संरचना में क्षेत्रों की संख्या बढ़ जाती है (जैसे, पता, मकान किराया भत्ता, आदि जोड़कर), fprintf() का उपयोग करके संरचनाएं लिखना, या fscanf() का उपयोग करके उन्हें पढ़ना, कठिन हो जाएगा।

रिकॉर्ड्स को संशोधित करना

हम बाइनरी मोड से / से रिकॉर्ड पढ़ना या लिखना जानते हैं। लेकिन क्या होगा अगर हम किसी मौजूदा रिकॉर्ड को संशोधित करना चाहते हैं? ठीक है, जब हम एक फ़ाइल खोलते हैं fopen() एक संरचना के लिए एक सूचक देता है। इस संरचना में एक पॉइंटर होता है जो फ़ाइल में पहले रिकॉर्ड की ओर इशारा करता है। fread() हमेशा उस रिकॉर्ड को पढ़ता है जहां पॉइंटर वर्तमान में रखा गया है। इसी तरह, fwrite() हमेशा उस रिकॉर्ड को लिखता है जहां पॉइंटर वर्तमान में रखा गया है। फ़ंक्शन fread () या fwrite () का उपयोग करने पर, पॉइंटर अगले रिकॉर्ड की शुरुआत में चला जाता है। किसी फ़ाइल को बंद करने पर पॉइंटर निष्क्रिय हो जाता है।

रिवाइंड () फ़ंक्शन पॉइंटर को फ़ाइल की शुरुआत में रखता है। इस बात की परवाह किए बिना कि वह अभी कहां मौजूद है। fseek() फ़ंक्शन हमें पॉइंटर को एक रिकॉर्ड से दूसरे रिकॉर्ड में ले जाने देता है। फ़ाइल में मौजूदा रिकॉर्ड को संशोधित करने के लिए इन फ़ंक्शंस का उपयोग निम्न कोड में किया गया है।

prikud("\nEnter name of employee to modify: "); 
scanf("%s", emprame);
rewind (fp);
While (fread (&e, recsize, 1, fp)==1)
{
 if (strcmp(e.name, empname) ==0)
{
 printf ("\nEnter new name, age & bs ");
 scanf("%s %d %f", e.name, &e.age, &e.bs);
 fseek (fp, -recsize, SEEK_CUR);
 fwrite(&e, recsize, 1, fp);
  break;
}

पॉइंटर को उसकी वर्तमान स्थिति से पिछले रिकॉर्ड में ले जाने के लिए, हमने फ़ंक्शन का उपयोग किया है,

fseek (fp, -recsize, SEEK_CUR);

-recsize वर्तमान स्थिति से बाइट्स को पुन: आकार देकर पॉइंटर को वापस ले जाता है। SEEK_CUR “stdio.h” में परिभाषित एक मैक्रो है।

-इसी तरह, अगर हम फाइल में पिछले रिकॉर्ड से परे पॉइंटर रखना चाहते हैं तो हम इसका उपयोग कर सकते हैं|

freek (fp, 0, SEEK_END);

वास्तव में, -recsize या 0 केवल ऑफ़सेट हैं जो संकलक को बताते हैं कि पॉइंटर को संदर्भ स्थिति से कितने बाइट्स ले जाया जाना चाहिए। संदर्भ स्थिति SEEK_END, SEEK_CUR या SEEK_SET हो सकती है। SEEK END का अर्थ है फ़ाइल के अंत से पॉइंटर को स्थानांतरित करना, SEEK_CUR का अर्थ है पॉइंटर को उसकी वर्तमान स्थिति के संदर्भ में ले जाना और SEEK SET का अर्थ है पॉइंटर को फ़ाइल की शुरुआत के संदर्भ में ले जाना।

एक बार पॉइंटर ठीक से स्थित हो जाने के बाद, हमने एक नया रिकॉर्ड लिखा है जो मौजूदा रिकॉर्ड को अधिलेखित कर देता है।

यदि हम जानना चाहते हैं कि पॉइंटर अभी कहाँ स्थित है, तो हम फ़ंक्शन ftell () का उपयोग कर सकते हैं। यह इस स्थिति को एक लंबे इंट के रूप में लौटाता है जो फ़ाइल की शुरुआत से एक ऑफसेट है। ftell () के लिए एक नमूना कॉल नीचे दिखाया गया है।

position=ftell (fp);

जहां स्थिति एक int है।

Low-Level File i/o in c in hindi

निम्न-स्तरीय फ़ाइल I/O में, डेटा को अलग-अलग वर्णों के रूप में या स्ट्रिंग्स के रूप में स्वरूपित डेटा के रूप में नहीं लिखा जा सकता है। निम्न-स्तरीय फ़ाइल 1/0 फ़ंक्शंस में डेटा लिखने या पढ़ने का केवल एक ही तरीका है-बाइट्स से भरे बफर के रूप में।

डेटा से भरा बफर लिखना fwrite() फ़ंक्शन जैसा दिखता है। हालाँकि, fwrite () के विपरीत, प्रोग्रामर को डेटा के लिए बफर सेट करना चाहिए, लिखने से पहले उसमें उपयुक्त मान रखना चाहिए, और लिखने के बाद उन्हें बाहर निकालना चाहिए। इस प्रकार, निम्न-स्तरीय 1/0 फ़ंक्शंस में बफर प्रोग्राम का हिस्सा है, न कि उच्च-स्तरीय फ़ाइल I/O फ़ंक्शंस में अदृश्य होने के बजाय।

निम्न-स्तरीय फ़ाइल 1/0 फ़ंक्शन निम्नलिखित लाभ प्रदान करते हैं:

(ए) चूंकि ये फ़ंक्शन उन विधियों के समानांतर हैं जिनका उपयोग ओएस डिस्क पर लिखने के लिए करता है, वे उच्च-स्तरीय फ़ाइल I/O फ़ंक्शंस की तुलना में अधिक कुशल हैं।

(बी) चूंकि रूटीन की कम परतें होती हैं, इसलिए निम्न-स्तरीय 1/0 फ़ंक्शन अपने उच्च-स्तरीय समकक्षों की तुलना में तेज़ी से संचालित होते हैं।

आइए अब एक प्रोग्राम लिखें जो निम्न-स्तरीय फ़ाइल इनपुट/आउटपुट फ़ंक्शंस का उपयोग करता है।

एक निम्न-स्तरीय फ़ाइल-कॉपी प्रोग्राम

इससे पहले हमने चरित्र-दर-चरित्र के आधार पर एक फ़ाइल की सामग्री को दूसरी फ़ाइल में कॉपी करने के लिए एक प्रोग्राम लिखा था। हम स्रोत फ़ाइल से बाइट्स के एक हिस्से को पढ़ने के लिए उसी प्रोग्राम को फिर से लिख सकते हैं और फिर इस खंड को लक्ष्य फ़ाइल में लिख सकते हैं। ऐसा करते समय चंक को बफर में पढ़ा जाएगा और बफर से फाइल में लिखा जाएगा। ऐसा करने के लिए हम पुस्तकालय के कार्यों पर निर्भर रहने के बजाय बफर का प्रबंधन स्वयं करेंगे। यह इस कार्यक्रम के बारे में निम्न-स्तर है। यहां एक कार्यक्रम है जो दिखाता है कि यह कैसे किया जा सकता है।

/*File-copy program which copies text, .com and .exe files */ 

#include <fcntl.h>
#include <ssys\types.h>
#include<sys\stat.h>
#include<stdio.h>
Int main()
{
  char buffer[512], source [128], target [128];
    Int  in, out, bytes; 
    Printf ("\nEnter source file name:");
    gets (source);
    In=open (source, O_RDONLY | O_BINARY);
    if (in == -1)
    {
      Puts("Cannot open file"); exit (1);
    }
    Printf("\nEnter target file name :");
    gets(target);
    Out=open(target, O_CREAT |O_BINARY |O_WRONLY, S_IWRITE);
    if(out == -1)
    {
      Puts("cannot open file");
      Close(in); exit (2);
    }
    While (1)
    {
      bytes=read (in, buffer, 512);
      If (bytes>0)
      Write(out, buffer, bytes);
      else
         Break;
    }
    Close (in); close(out);
    return 0 ; 
}

बफर घोषित(Declaring) करना

इस प्रोग्राम में आप जो पहला अंतर देखेंगे, वह यह है कि हम एक कैरेक्टर बफर घोषित करते हैं,

Char buffer [512];

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

एक फाइल खोलना

हमने अपने प्रोग्राम में दो फाइलें खोली हैं, एक स्रोत फ़ाइल है जिससे हम जानकारी पढ़ते हैं, और दूसरी लक्ष्य फ़ाइल है जिसमें हम स्रोत फ़ाइल से पढ़ी गई जानकारी लिखते हैं।

जैसा कि उच्च-स्तरीय फ़ाइल I/O में होता है, फ़ाइल को एक्सेस करने से पहले उसे खोला जाना चाहिए

यह कथन का उपयोग करके किया जाता है,

ओपन सोर्स में, O_RDONLY | O_BINARY)

हमेशा की तरह, हमें ओपन (), फ़ाइल नाम और उस मोड की आपूर्ति करनी होगी जिसमें हम फ़ाइल खोलना चाहते हैं। संभावित फ़ाइल खोलने के तरीके नीचे दिए गए हैं।

O_APPENDसंलग्न करने के लिए एक फाइल खोलता है
O_CREATलिखने के लिए एक नई फ़ाइल बनाता है (यदि फ़ाइल मौजूद है तो कोई प्रभाव नहीं)
O_RDONLYकेवल पढ़ने के लिए एक नई फ़ाइल खोलता है
O_RDWRपढ़ने और लिखने दोनों के लिए एक फाइल बनाता है
O_WRONLYकेवल लिखने के लिए एक फाइल बनाता है
O_BINARYफ़ाइल को बाइनरी मोड में खोलता है
O_TEXTटेक्स्ट मोड में फ़ाइल खोलता है

ये ‘ओ-फ्लैग्स’ फ़ाइल “fcntl.h” में परिभाषित हैं। इसलिए निम्न-स्तरीय फ़ाइल I/O का उपयोग करते समय इस फ़ाइल को प्रोग्राम में शामिल किया जाना चाहिए। जब दो या दो से अधिक ओ-फ्लैग एक साथ उपयोग किए जाते हैं, तो वे बिटवाइज़ या ऑपरेटर का उपयोग करके संयुक्त होते हैं (1) अध्याय 21 में बिटवाइज़ ऑपरेटरों पर विस्तार से चर्चा की गई है।

फाइल को खोलने के लिए हमारे प्रोग्राम में इस्तेमाल किया जाने वाला दूसरा स्टेटमेंट है,

out-open(target, O_CREATIO_BINARY | 0_WRONLY. 5 IWRITE);

ध्यान दें कि चूंकि लक्ष्य फ़ाइल खोले जाने पर मौजूद नहीं है, इसलिए हमने O CREAT ध्वज का उपयोग किया है, और चूंकि हम फ़ाइल को लिखना चाहते हैं, इसलिए हमने O WRONLY का उपयोग किया है। और अंत में, चूंकि हम फ़ाइल को बाइनरी मोड में खोलना चाहते हैं, इसलिए हमने O_BINARY . का उपयोग किया है|

जब भी O_CREAT flag का उपयोग किया जाता है, तो फ़ाइल के पढ़ने/लिखने की स्थिति को इंगित करने के लिए open() फ़ंक्शन में एक और तर्क जोड़ा जाना चाहिए। इस तर्क को ‘अनुमति तर्क’ कहा जाता है। अनुमति तर्क निम्न में से कोई भी हो सकता है:

S_IWRITE – अनुमत फ़ाइल में लिखना

S_IREAD – अनुमत फ़ाइल से पढ़ना

इन अनुमतियों का उपयोग करने के लिए, “sys” फ़ोल्डर में मौजूद “type.h” और “stat.h” दोनों फाइलों को “fcntl.h” के साथ प्रोग्राम में #शामिल किया जाना चाहिए।

फ़ाइल हैंडल

फ़ाइल पॉइंटर को fopen() के रूप में वापस करने के बजाय, निम्न-स्तरीय फ़ाइल I/O में, open() ‘फ़ाइल हैंडल’ नामक एक पूर्णांक मान देता है। यह एक विशेष फ़ाइल को निर्दिष्ट एक संख्या है, जिसका उपयोग उसके बाद फ़ाइल को संदर्भित करने के लिए किया जाता है। यदि खुला () -1 का मान देता है, तो इसका मतलब है कि फ़ाइल को सफलतापूर्वक खोला नहीं जा सका।

बफर और फाइल के बीच इंटरेक्शन

निम्न स्टेटमेंट फ़ाइल को पढ़ता है या जितना अधिक बफर में फिट होगा:

bytes = read ( inhandle, buffer, 512);

यहां पहला तर्क फ़ाइल हैंडल है, दूसरा बफर का पता है और तीसरा बाइट्स की अधिकतम संख्या है जिसे हम पढ़ना चाहते हैं।

फ़ाइल की प्रतिलिपि बनाने के लिए, हमें थोड़ी देर में पढ़ने () और लिखने () दोनों कार्यों का उपयोग करना चाहिए। रीड () फ़ंक्शन वास्तव में पढ़े गए बाइट्स की संख्या देता है। यह वेरिएबल बाइट्स को सौंपा गया है। इस वेरिएबल का उपयोग यह बताने के लिए किया जाता है कि बफर से लक्ष्य फ़ाइल में लिखने के लिए कितने बाइट्स लिखें () हैं।

Previous articlefile input/output in c in hindi| c में फ़ाइल इनपुट/आउटपुट क्या होता है?
Next articleWhat is the difference between C and C++? |c interview questions and answers for freshers

1 COMMENT

LEAVE A REPLY

Please enter your comment!
Please enter your name here