സി, ഡോക്യുമെൻ്റ് റീഡിംഗ് ആൻഡ് റൈറ്റിംഗ്

ബൈനറി ഫയൽ പ്രോസസ്സ് ചെയ്തിട്ടുണ്ടെങ്കിൽ, മുകളിൽ പറഞ്ഞവ മാറ്റിസ്ഥാപിക്കുന്നതിന് ഇനിപ്പറയുന്ന ആക്സസ് മോഡ് ഉപയോഗിക്കുക:

"rb", "wb", "ab", "rb+", "r+b", "wb+", "w+b", "ab+", "a+b"

അടച്ച ഫയൽ

ഫയൽ അടയ്ക്കുന്നതിന്, ദയവായി fclose() ഫംഗ്ഷൻ ഉപയോഗിക്കുക. പ്രവർത്തനത്തിൻ്റെ പ്രോട്ടോടൈപ്പ് ഇപ്രകാരമാണ്:

int fclose (FILE *fp);

• ഫയൽ വിജയകരമായി അടച്ചാൽ, fclose() ഫംഗ്‌ഷൻ പൂജ്യം നൽകുന്നു, പിശക് EOF നൽകുന്നു. ഈ ഫംഗ്‌ഷൻ, വാസ്തവത്തിൽ, ബഫറിൽ നിന്ന് ഡാറ്റ നീക്കംചെയ്യുകയും ഫയൽ അടയ്ക്കുകയും ആ ഫയലിനായി ഉപയോഗിക്കുന്ന എല്ലാ മെമ്മറിയും റിലീസ് ചെയ്യുകയും ചെയ്യുന്നു. stdio.h എന്ന ഹെഡർ ഫയലിൽ നിർവചിച്ചിരിക്കുന്ന സ്ഥിരാങ്കമാണ് EOF

C സ്റ്റാൻഡേർഡ് ലൈബ്രറി ഫയലുകൾ അക്ഷരങ്ങൾ അല്ലെങ്കിൽ ഒരു നിശ്ചിത-ദൈർഘ്യ സ്ട്രിംഗ് ആയി വായിക്കുന്നതിനും എഴുതുന്നതിനും വിവിധ പ്രവർത്തനങ്ങൾ നൽകുന്നു.

ഫയലിലേക്ക് എഴുതുക

സ്ട്രീമിലേക്ക് പ്രതീകങ്ങൾ എഴുതുന്നതിനുള്ള ഏറ്റവും ലളിതമായ പ്രവർത്തനങ്ങൾ ഇതാ:

int fputc ( int c , FILE *fp );

fputc () എന്ന ഫംഗ്‌ഷൻ c പരാമീറ്ററിൻ്റെ പ്രതീക മൂല്യം fp പോയിൻ്റ് ചെയ്യുന്ന ഔട്ട്‌പുട്ട് സ്ട്രീമിലേക്ക് എഴുതുന്നു. എഴുത്തുകൾ വിജയകരമാണെങ്കിൽ, ഒരു പിശക് സംഭവിച്ചാൽ അത് എഴുതിയ പ്രതീകവും EOF ഉം നൽകുന്നു. സ്ട്രീമിലേക്ക് നൾ ഉപയോഗിച്ച് അവസാനിക്കുന്ന ഒരു സ്ട്രിംഗ് എഴുതാൻ നിങ്ങൾക്ക് ഇനിപ്പറയുന്ന ഫംഗ്ഷൻ ഉപയോഗിക്കാം:

int fputs ( const char *s , FILE *fp );

fputs () എന്ന ഫംഗ്‌ഷൻ, fp പോയിൻ്റ് ചെയ്യുന്ന ഔട്ട്‌പുട്ട് സ്ട്രീമിലേക്ക് s എന്ന സ്ട്രിംഗ് എഴുതുന്നു. എഴുത്തുകൾ വിജയിക്കുകയാണെങ്കിൽ, അത് ഒരു നോൺ-നെഗറ്റീവ് മൂല്യവും ഒരു പിശക് സംഭവിച്ചാൽ EOF ഉം നൽകുന്നു. ഫയലിലേക്ക് ഒരു സ്ട്രിംഗ് എഴുതുന്ന int fprintf (FILE * fp, const char * ഫോർമാറ്റ്,...) ഫംഗ്‌ഷനും നിങ്ങൾക്ക് ഉപയോഗിക്കാം. ഇനിപ്പറയുന്ന ഉദാഹരണം പരീക്ഷിക്കുക:

കുറിപ്പ്: നിങ്ങൾക്ക് ലഭ്യമായ ഒരു tmp ഡയറക്ടറി ഉണ്ടെന്ന് ഉറപ്പുവരുത്തുക, അത് നിലവിലില്ലെങ്കിൽ, ആദ്യം നിങ്ങളുടെ കമ്പ്യൂട്ടറിൽ അത് സൃഷ്ടിക്കേണ്ടതുണ്ട്.

/ tmp സാധാരണയായി ലിനക്സ് സിസ്റ്റത്തിലെ ഒരു താൽക്കാലിക ഡയറക്ടറിയാണ്. നിങ്ങൾ വിൻഡോസ് സിസ്റ്റത്തിലാണ് പ്രവർത്തിക്കുന്നതെങ്കിൽ, പ്രാദേശിക പരിതസ്ഥിതിയിൽ നിലവിലുള്ള ഒരു ഡയറക്ടറിയിലേക്ക് അത് പരിഷ്കരിക്കേണ്ടതുണ്ട്, ഉദാഹരണത്തിന്: C: \ tmp, D: \ tmp, മുതലായവ.

ജീവിക്കുന്ന ഉദാഹരണം

#ഉൾപ്പെടുത്തുക int main () {FILE *fp = NULL ; fp = fopen ("/tmp/test.txt ", "w+"); fprintf (fp , "ഇത് fprintf എന്നതിനായുള്ള പരിശോധനയാണ്...\n "); fputs ("ഇത് fputs-നുള്ള പരിശോധനയാണ്...\n ", fp ); fclose (fp ); }

മുകളിലെ കോഡ് കംപൈൽ ചെയ്ത് എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ, അത് /tmp ഡയറക്ടറിയിലെ test.txt എന്ന പുതിയ ഫയൽ സൃഷ്ടിക്കുന്നു. കൂടാതെ രണ്ട് വ്യത്യസ്ത ഫംഗ്ഷനുകൾ ഉപയോഗിച്ച് രണ്ട് വരികളിലേക്ക് എഴുതുന്നു. അടുത്തതായി ഈ ഫയൽ വായിക്കാം.

ഫയൽ വായിക്കുക

ഒരു ഫയലിൽ നിന്ന് ഒരു പ്രതീകം വായിക്കുന്നതിനുള്ള ഏറ്റവും ലളിതമായ ഫംഗ്‌ഷൻ ഇനിപ്പറയുന്നതാണ്:

int fgetc (FILE * fp);

fgetc () ഫംഗ്ഷൻ, fp പോയിൻ്റ് ചെയ്യുന്ന ഇൻപുട്ട് ഫയലിൽ നിന്ന് ഒരു പ്രതീകം വായിക്കുന്നു. റിട്ടേൺ മൂല്യം റീഡ് പ്രതീകവും ഒരു പിശക് സംഭവിച്ചാൽ EOF ഉം ആണ്. ഒരു സ്ട്രീമിൽ നിന്ന് ഒരു സ്ട്രിംഗ് വായിക്കാൻ ഇനിപ്പറയുന്ന ഫംഗ്ഷൻ നിങ്ങളെ അനുവദിക്കുന്നു:

char *fgets (char *buf, int n, FILE *fp);

fget () എന്ന ഫംഗ്‌ഷൻ fp സംവിധാനം ചെയ്യുന്ന ഇൻപുട്ട് സ്ട്രീമിൽ നിന്ന് n-1 പ്രതീകങ്ങൾ വായിക്കുന്നു. ഇത് റീഡ് സ്‌ട്രിംഗ് ബഫർ ബഫിലേക്ക് പകർത്തുകയും സ്‌ട്രിംഗ് അവസാനിപ്പിക്കുന്നതിന് അവസാനം ഒരു ശൂന്യ പ്രതീകം ചേർക്കുകയും ചെയ്യുന്നു.

അവസാന പ്രതീകം വായിക്കുന്നതിന് മുമ്പ് ഈ ഫംഗ്‌ഷൻ ഒരു തകർന്ന ലൈൻ പ്രതീകമായ '\ n' അല്ലെങ്കിൽ ഫയലിൻ്റെ അവസാനത്തിൻ്റെ EOF നേരിടുകയാണെങ്കിൽ, ലൈൻ ബ്രേക്കുകൾ ഉൾപ്പെടെയുള്ള റീഡ് പ്രതീകങ്ങളിലേക്ക് മാത്രമേ മടങ്ങൂ. ഫയലിൽ നിന്നുള്ള സ്ട്രിംഗ് വായിക്കാൻ നിങ്ങൾക്ക് int fscanf (FILE * fp, const char * ഫോർമാറ്റ്,...) ഫംഗ്‌ഷൻ ഉപയോഗിക്കാം, എന്നാൽ ആദ്യത്തെ സ്‌പെയ്‌സും ലൈൻ ബ്രേക്കും നേരിടുമ്പോൾ അത് വായന നിർത്തുന്നു.

ജീവിക്കുന്ന ഉദാഹരണം

#ഉൾപ്പെടുത്തുക int main () {FILE *fp = NULL ; ചാർ ബഫ് [255]; fp = fopen ("/tmp/test.txt ", "r "); fscanf (fp , "%s ", buff ); printf ("1: %s \n ", buff ); fgets (buff , 255, (FILE *)fp ); printf ("2: %s \n ", buff ); fgets (buff , 255, (FILE *)fp ); printf ("3: %s \n ", buff ); fclose (fp ); }

മുകളിലുള്ള കോഡ് കംപൈൽ ചെയ്‌ത് എക്‌സിക്യൂട്ട് ചെയ്യുമ്പോൾ, അത് മുമ്പത്തെ വിഭാഗത്തിൽ സൃഷ്‌ടിച്ച ഫയലുകൾ വായിക്കുകയും ഇനിപ്പറയുന്ന ഫലങ്ങൾ പുറപ്പെടുവിക്കുകയും ചെയ്യുന്നു:

1: ഇത് 2: fprintf-നായി പരീക്ഷിക്കുന്നു...

3: ഇത് fputs-നുള്ള പരിശോധനയാണ്...

ആദ്യം, fscanf() ൻ്റെ രീതി ഇത് വായിക്കുന്നു .കാരണം അത് പിന്നിൽ ഒരു ഇടം നേരിടുന്നു. രണ്ടാമതായി, വരിയുടെ അവസാനം വരെ ശേഷിക്കുന്ന ഭാഗം വായിക്കാൻ ഫങ്‌ടൺ fgets () എന്ന് വിളിക്കുക. അവസാനമായി, രണ്ടാമത്തെ വരി പൂർണ്ണമായും വായിക്കാൻ fgets () എന്ന് വിളിക്കുക.

ബൈനറി I / O ഫംഗ്‌ഷൻ

ബൈനറി ഇൻപുട്ടിനും ഔട്ട്പുട്ടിനുമായി ഇനിപ്പറയുന്ന രണ്ട് ഫംഗ്ഷനുകൾ ഉപയോഗിക്കുന്നു:

size_t ഫ്രെഡ് (അസാധുവായ *ptr, size_t size_of_elements, size_t number_of_elements, FILE *a_file ); size_t fwrite (const void *ptr, size_t size_of_elements, size_t number_of_elements, FILE *a_file );

രണ്ട് ഫംഗ്ഷനുകളും സ്റ്റോറേജ് ബ്ലോക്കുകൾക്കായി വായിക്കുകയും എഴുതുകയും ചെയ്യുന്നു-സാധാരണയായി അറേകൾ അല്ലെങ്കിൽ ഘടനകൾ.

മുകളിൽ C ഫയൽ റീഡിംഗ് ആൻഡ് റൈറ്റിംഗ് HDV Phoelectron Technology Ltd. എന്ന സോഫ്റ്റ്‌വെയർ സാങ്കേതിക പ്രവർത്തനത്തിൻ്റെതാണ്. നെറ്റ്‌വർക്ക് അനുബന്ധ ഉപകരണങ്ങൾക്കായുള്ള കമ്പനിയും (ഉദാ: എസിഒ.എൻ.യു/ ആശയവിനിമയംഒ.എൻ.യു/ ബുദ്ധിമാൻഒ.എൻ.യു/ ഫൈബർഒ.എൻ.യു, മുതലായവ) ശക്തമായ ഒരു സോഫ്‌റ്റ്‌വെയർ ടീമിനെ ഒരുമിച്ച് കൊണ്ടുവന്നിട്ടുണ്ട്, ഓരോ ഉപഭോക്താവിനും ആവശ്യമുള്ള പ്രത്യേക ആവശ്യങ്ങൾ ഇഷ്‌ടാനുസൃതമാക്കുകയും ഞങ്ങളുടെ ഉൽപ്പന്നങ്ങൾ കൂടുതൽ ബുദ്ധിപരവും വികസിതവുമാക്കുകയും ചെയ്യുന്നു.