ಸಿ, ಡಾಕ್ಯುಮೆಂಟ್ ಓದುವಿಕೆ ಮತ್ತು ಬರವಣಿಗೆ

ಬೈನರಿ ಫೈಲ್ ಅನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಿದರೆ, ಮೇಲಿನದನ್ನು ಬದಲಾಯಿಸಲು ಕೆಳಗಿನ ಪ್ರವೇಶ ಮೋಡ್ ಅನ್ನು ಬಳಸಿ:

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

ಮುಚ್ಚಿದ ಫೈಲ್

ಫೈಲ್ ಅನ್ನು ಮುಚ್ಚಲು, ದಯವಿಟ್ಟು fclose() ಕಾರ್ಯವನ್ನು ಬಳಸಿ. ಕಾರ್ಯದ ಮೂಲಮಾದರಿಯು ಈ ಕೆಳಗಿನಂತಿರುತ್ತದೆ:

int fclose (FILE *fp);

• ಫೈಲ್ ಅನ್ನು ಯಶಸ್ವಿಯಾಗಿ ಮುಚ್ಚಿದರೆ, fclose() ಕಾರ್ಯವು ಶೂನ್ಯವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಮತ್ತು ದೋಷವು EOF ಅನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ. ಈ ಕಾರ್ಯವು ವಾಸ್ತವವಾಗಿ, ಬಫರ್‌ನಿಂದ ಡೇಟಾವನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ, ಫೈಲ್ ಅನ್ನು ಮುಚ್ಚುತ್ತದೆ ಮತ್ತು ಆ ಫೈಲ್‌ಗೆ ಬಳಸಲಾದ ಎಲ್ಲಾ ಮೆಮೊರಿಯನ್ನು ಬಿಡುಗಡೆ ಮಾಡುತ್ತದೆ. EOF ಎಂಬುದು ಹೆಡರ್ ಫೈಲ್ stdio.h ನಲ್ಲಿ ಸ್ಥಿರವಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ

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

ಮೇಲಿನ ಕೋಡ್ ಅನ್ನು ಕಂಪೈಲ್ ಮಾಡಿದಾಗ ಮತ್ತು ಕಾರ್ಯಗತಗೊಳಿಸಿದಾಗ, ಅದು ಹೊಸ ಫೈಲ್ test.txt inthe / tmp ಡೈರೆಕ್ಟರಿಯನ್ನು ರಚಿಸುತ್ತದೆ. ಮತ್ತು ಎರಡು ವಿಭಿನ್ನ ಕಾರ್ಯಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಎರಡು ಸಾಲುಗಳಿಗೆ ಬರೆಯುತ್ತದೆ. ಈ ಫೈಲ್ ಅನ್ನು ಮುಂದೆ ಓದೋಣ.

ಫೈಲ್ ಓದಿ

ಫೈಲ್‌ನಿಂದ ಒಂದೇ ಅಕ್ಷರವನ್ನು ಓದಲು ಕೆಳಗಿನ ಸರಳ ಕಾರ್ಯವಾಗಿದೆ:

int fgetc (FILE * fp);

fgetc () ಕಾರ್ಯವು ಎಫ್‌ಪಿ ಪಾಯಿಂಟ್‌ಗಳ ಇನ್‌ಪುಟ್ ಫೈಲ್‌ನಿಂದ ಅಕ್ಷರವನ್ನು ಓದುತ್ತದೆ. ರಿಟರ್ನ್ ಮೌಲ್ಯವು ಓದುವ ಅಕ್ಷರವಾಗಿದೆ ಮತ್ತು ದೋಷ ಸಂಭವಿಸಿದಲ್ಲಿ EOF ಆಗಿದೆ. ಕೆಳಗಿನ ಕಾರ್ಯವು ಸ್ಟ್ರೀಮ್‌ನಿಂದ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಓದಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ:

ಚಾರ್ * fgets (ಚಾರ್ * ಬಫ್, ಇಂಟ್ ಎನ್, ಫೈಲ್ * ಎಫ್ಪಿ);

fgets () ಕಾರ್ಯವು 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: ಇದು ಎಫ್‌ಪುಟ್‌ಗಳಿಗಾಗಿ ಪರೀಕ್ಷೆಯಾಗಿದೆ...

ಮೊದಲನೆಯದಾಗಿ, fscanf() ನ ವಿಧಾನವು ಕೇವಲ ಇದನ್ನು ಓದುತ್ತದೆ .ಏಕೆಂದರೆ ಅದು ಹಿಂಭಾಗದಲ್ಲಿ ಒಂದು ಜಾಗವನ್ನು ಎದುರಿಸುತ್ತದೆ. ಎರಡನೆಯದಾಗಿ, ಸಾಲಿನ ಅಂತ್ಯದವರೆಗೆ ಉಳಿದ ಭಾಗವನ್ನು ಓದಲು ಫಂಕ್ಟನ್ ಫ್ಗೆಟ್ಸ್ () ಗೆ ಕರೆ ಮಾಡಿ. ಅಂತಿಮವಾಗಿ, ಎರಡನೇ ಸಾಲನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಓದಲು fgets () ಗೆ ಕರೆ ಮಾಡಿ.

ಬೈನರಿ I / O ಕಾರ್ಯ

ಬೈನರಿ ಇನ್‌ಪುಟ್ ಮತ್ತು ಔಟ್‌ಪುಟ್‌ಗಾಗಿ ಈ ಕೆಳಗಿನ ಎರಡು ಕಾರ್ಯಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ:

size_t fread (ಅನೂರ್ಜಿತ * 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 ಫೋಎಲೆಕ್ಟ್ರಾನ್ ಟೆಕ್ನಾಲಜಿ ಲಿಮಿಟೆಡ್‌ಗೆ ಸೇರಿದೆ, ಇದು ಸಾಫ್ಟ್‌ವೇರ್ ತಾಂತ್ರಿಕ ಕಾರ್ಯಾಚರಣೆಯಾಗಿದೆ. ಮತ್ತು ನೆಟ್‌ವರ್ಕ್ ಸಂಬಂಧಿತ ಸಲಕರಣೆಗಳಿಗಾಗಿ ಕಂಪನಿ (ಉದಾಹರಣೆಗೆ: ACONU/ ಸಂವಹನONU/ ಬುದ್ಧಿವಂತONU/ ಫೈಬರ್ONU, ಇತ್ಯಾದಿ) ಪ್ರಬಲ ಸಾಫ್ಟ್‌ವೇರ್ ತಂಡವನ್ನು ಒಟ್ಟುಗೂಡಿಸಿದೆ, ಪ್ರತಿಯೊಬ್ಬ ಗ್ರಾಹಕರು ಅಗತ್ಯವಿರುವ ವಿಶೇಷ ಬೇಡಿಕೆಗಳನ್ನು ಕಸ್ಟಮೈಸ್ ಮಾಡುತ್ತಾರೆ, ನಮ್ಮ ಉತ್ಪನ್ನಗಳು ಹೆಚ್ಚು ಬುದ್ಧಿವಂತ ಮತ್ತು ಸುಧಾರಿತವಾಗಿರಲಿ.