ឯកសារអត្ថបទ

សូមក្រឡេកមើលការធ្វើការជាមួយឯកសារអត្ថបទនៅក្នុង C ដោយប្រើឧទាហរណ៍មួយ។ បង្កើតឯកសារអត្ថបទនៅលើដ្រាយ C ដែលមានឈ្មោះថា TextFile.txt ។ វាយបញ្ចូលបន្ទាត់ខាងក្រោមក្នុងឯកសារនេះ៖

String_1 123 String_11, 456
ខ្សែអក្សរ_២
ខ្សែអក្សរ_៣

រក្សាទុកឯកសារ។

ហើយនេះគឺជាកូដសម្រាប់កម្មវិធី C ដែលបើកឯកសាររបស់យើង ហើយអានបន្ទាត់ពីវា៖

/* *អ្នកនិពន្ធ៖ @author Subbotin B.P..h> #include #កំណត់ LEN 50 int main(void) ( puts("Text file operations"); char cArray; FILE *pTextFile = fopen("C:\\TextFile.txt", "r"); if(pTextFile == NULL) ( puts("បញ្ហា"); ត្រឡប់ EXIT_FAILURE; ) while(fgets(cArray, LEN, pTextFile) != NULL) ( printf("%s", cArray); ) fclose(pTextFile);

ដើម្បីបើកឯកសារអត្ថបទក្នុង C សូមប្រើមុខងារ fopen៖

ឯកសារ *pTextFile = fopen("C:\\TextFile.txt", "r");

អាគុយម៉ង់ទីមួយចំពោះមុខងារ fopen ចង្អុលទៅឯកសារមួយ ហើយទីពីរនិយាយថាឯកសារត្រូវបានបើកសម្រាប់អានពីវា។

យើងអានបន្ទាត់ដោយប្រើមុខងារ fgets៖

fgets(cArray, LEN, pTextFile);

អាគុយម៉ង់ទីមួយនៃមុខងារ fgets ចង្អុលទៅអារេតួអក្សរដែលខ្សែអក្សរដែលបានទទួលនឹងត្រូវបានរក្សាទុក អាគុយម៉ង់ទីពីរគឺជាចំនួនអតិបរមានៃតួអក្សរដែលត្រូវអាន ហើយទីបីគឺជាឯកសាររបស់យើង។

បន្ទាប់ពីបញ្ចប់ការធ្វើការជាមួយឯកសារ អ្នកត្រូវបិទវា៖

fclose(pTextFile);

យើង​ទទួល​បាន:

អក្សររុស្ស៊ីក៏លេចឡើងនៅក្នុងបន្ទាត់។

និយាយអីញ្ចឹង ខ្ញុំបង្កើតកម្មវិធីនេះជា Eclipse។ អ្នកអាចមើលពីរបៀបធ្វើការជាមួយ C/C++ នៅក្នុង Eclipse ។

ដូច្នេះ យើងបើក និងអានទិន្នន័យពីឯកសារអត្ថបទ។

ឥឡូវនេះយើងនឹងរៀនពីរបៀបបង្កើតឯកសារអត្ថបទដោយកម្មវិធី និងសរសេរទិន្នន័យទៅវា។

/* អ្នកនិពន្ធ៖ @author Subbotin B.P..h> #include int main(void) ( FILE *pTextFile = fopen("C:\\TextFileW.txt", "w"); char *cString = "នេះគឺជាខ្សែអក្សរ"; char cNewLine = "\n"; int nVal = 123 ; if(pTextFile == NULL) ( puts("Problems"); ត្រឡប់ EXIT_FAILURE; ) fprintf(pTextFile, "%s%c", cString, cNewLine);

បង្កើតឯកសារអត្ថបទដើម្បីសរសេរទិន្នន័យទៅ៖

ឯកសារ *pTextFile = fopen("C:\\TextFileW.txt", "w");

ប្រសិនបើឯកសារមានរួចហើយ វានឹងត្រូវបានបើក ហើយទិន្នន័យទាំងអស់ពីវានឹងត្រូវបានលុប។

cString អក្សរ C និងលេខ nVal ត្រូវបានសរសេរដោយកម្មវិធីទៅជាឯកសារអត្ថបទ។ cNewLine គឺគ្រាន់តែជាបន្ទាត់ថ្មី។

យើងសរសេរទិន្នន័យទៅឯកសារអត្ថបទដោយប្រើមុខងារ fprintf៖

fprintf(pTextFile, "%s%c", cString, cNewLine);

អាគុយម៉ង់ទីមួយនៅទីនេះគឺជាឯកសាររបស់យើង ទីពីរគឺជាខ្សែអក្សរទ្រង់ទ្រាយ ទីបីឬច្រើនគឺជាចំនួនអាគុយម៉ង់ដែលត្រូវការសម្រាប់ទម្រង់នេះ។

ស្លាក: ឯកសារអត្ថបទ, fopen, fclose, feof, setbuf, setvbuf, fflush, fgetc, fprintf, fscanf, fgets, buffed stream, unbuffered stream។

ធ្វើការជាមួយឯកសារអត្ថបទ

ការធ្វើការជាមួយឯកសារអត្ថបទគឺស្រដៀងនឹងការធ្វើការជាមួយកុងសូល៖ ដោយប្រើមុខងារបញ្ចូលដែលបានធ្វើទ្រង់ទ្រាយ យើងរក្សាទុកទិន្នន័យទៅក្នុងឯកសារ ដោយប្រើមុខងារលទ្ធផលដែលបានធ្វើទ្រង់ទ្រាយ យើងអានទិន្នន័យពីឯកសារមួយ។ មាន nuances ជាច្រើនដែលយើងនឹងមើលនៅពេលក្រោយ។ ប្រតិបត្តិការសំខាន់ៗដែលត្រូវធ្វើគឺ

• 1. បើកឯកសារដើម្បីឱ្យវាអាចចូលបាន។ ដូច្នោះហើយ អ្នកអាចបើកវាសម្រាប់អាន សរសេរ អាន និងសរសេរឡើងវិញ ឬសរសេរទៅចុងបញ្ចប់នៃឯកសារ។ល។ នៅពេលអ្នកបើកឯកសារ កំហុសជាច្រើនក៏អាចកើតឡើងផងដែរ - ឯកសារប្រហែលជាមិនមានទេ វាអាចជាប្រភេទឯកសារខុស អ្នកប្រហែលជាមិនមានការអនុញ្ញាតឱ្យធ្វើការជាមួយឯកសារ។ល។ ទាំងអស់នេះត្រូវតែយកទៅក្នុងគណនី។
• 2. ធ្វើការដោយផ្ទាល់ជាមួយឯកសារ - ការសរសេរនិងការអាន។ នៅទីនេះយើងក៏ត្រូវចងចាំផងដែរថាយើងមិនដំណើរការជាមួយអង្គចងចាំចូលដំណើរការដោយចៃដន្យទេ ប៉ុន្តែជាមួយនឹងស្ទ្រីមដែលជាប់គាំង ដែលបន្ថែមភាពជាក់លាក់របស់វាផ្ទាល់។
• 3. បិទឯកសារ។ ដោយសារឯកសារគឺជាធនធានខាងក្រៅរបស់កម្មវិធី ប្រសិនបើវាមិនត្រូវបានបិទ វានឹងបន្តព្យួរក្នុងអង្គចងចាំ សូម្បីតែបន្ទាប់ពីកម្មវិធីត្រូវបានបិទក៏ដោយ (ឧទាហរណ៍ វានឹងមិនអាចលុបឯកសារបើក ឬធ្វើការផ្លាស់ប្តូរបានទេ)។ ល។ ) លើសពីនេះទៀត ពេលខ្លះមិនចាំបាច់បិទ ប៉ុន្តែត្រូវ "បើកឡើងវិញ" ឯកសារតាមលំដាប់លំដោយ ឧទាហរណ៍ ដើម្បីប្តូររបៀបចូលប្រើ។

លើសពីនេះ មានកិច្ចការមួយចំនួនទៀត នៅពេលដែលយើងមិនចាំបាច់ចូលប្រើខ្លឹមសារនៃឯកសារ៖ ប្តូរឈ្មោះ ផ្លាស់ទី ចម្លង។ល។ ជាអកុសល ស្តង់ដារ C មិនមានការពិពណ៌នាអំពីមុខងារសម្រាប់តម្រូវការទាំងនេះទេ។ ជាការពិតណាស់ ពួកវាមានសម្រាប់ការអនុវត្តកម្មវិធីចងក្រងនីមួយៗ។ ការអានមាតិកានៃថតឯកសារ (ថត, ថត) ក៏កំពុងចូលប្រើឯកសារមួយដែរ ពីព្រោះថតឯកសារខ្លួនវាជាឯកសារដែលមានទ្រង់ទ្រាយមេតា។

ពេលខ្លះចាំបាច់ត្រូវអនុវត្តប្រតិបត្តិការជំនួយមួយចំនួន៖ ផ្លាស់ទីទៅទីតាំងដែលចង់បានក្នុងឯកសារ ចងចាំទីតាំងបច្ចុប្បន្ន កំណត់ប្រវែងឯកសារ។ល។

ដើម្បីធ្វើការជាមួយឯកសារ អ្នកត្រូវការវត្ថុ FILE ។ វត្ថុនេះរក្សាទុកឧបករណ៍កំណត់អត្តសញ្ញាណរបស់ស្ទ្រីមឯកសារ និងព័ត៌មានដែលត្រូវការដើម្បីគ្រប់គ្រងវា រួមទាំងទ្រនិចទៅសតិបណ្ដោះអាសន្នរបស់វា សូចនាករទីតាំងឯកសារ និងសូចនាករស្ថានភាព។

វត្ថុ FILE គឺជារចនាសម្ព័ន្ធដោយខ្លួនឯង ប៉ុន្តែវាលរបស់វាមិនគួរត្រូវបានចូលប្រើទេ។ កម្មវិធីចល័តត្រូវតែចាត់ទុកឯកសារជាវត្ថុអរូបីដែលអនុញ្ញាតឱ្យចូលប្រើការស្ទ្រីមឯកសារ។

ការបង្កើត និងការបែងចែកអង្គចងចាំសម្រាប់វត្ថុនៃប្រភេទ FILE ត្រូវបានអនុវត្តដោយប្រើមុខងារ fopen ឬ tmpfile (មានផ្សេងទៀត ប៉ុន្តែយើងនឹងផ្តោតលើចំណុចទាំងនេះប៉ុណ្ណោះ)។

មុខងារ fopen បើកឯកសារ។ វាទទួលបានអាគុយម៉ង់ពីរ - ខ្សែអក្សរដែលមានអាសយដ្ឋានឯកសារ និងខ្សែអក្សរដែលមានរបៀបចូលប្រើឯកសារ។ ឈ្មោះឯកសារអាចជាដាច់ខាត ឬទាក់ទង។ fopen ត្រឡប់ទ្រនិចទៅវត្ថុ FILE ដែលអាចត្រូវបានប្រើដើម្បីចូលប្រើឯកសារបន្ថែម។

ឯកសារ * fopen (ឈ្មោះឯកសារ const char * របៀប const char *);

ជាឧទាហរណ៍ សូមបើកឯកសារមួយ ហើយសរសេរ Hello World ទៅក្នុងវា។

# រួមបញ្ចូល # រួមបញ្ចូល # រួមបញ្ចូល void main() ( // ដោយប្រើអថេរឯកសារ យើងនឹងចូលប្រើឯកសារ FILE *file; // បើកឯកសារអត្ថបទដែលមានឯកសារអនុញ្ញាតការសរសេរ = fopen("C:/c/test.txt", "w+t") ; // សរសេរទៅឯកសារ fprintf (ឯកសារ "ជំរាបសួរពិភពលោក!" // បិទឯកសារ fclose (ឯកសារ);

មុខងារ fopen ខ្លួនវាបែងចែកអង្គចងចាំសម្រាប់ការសម្អាតវត្ថុត្រូវបានអនុវត្តដោយមុខងារ fclose ។ វាចាំបាច់ក្នុងការបិទឯកសារ; វានឹងមិនបិទដោយខ្លួនឯងទេ។

មុខងារ fopen អាច​បើក​ឯកសារ​ក្នុង​ទម្រង់​អត្ថបទ ឬ​ប្រព័ន្ធគោលពីរ។ លំនាំដើមគឺអត្ថបទ។ របៀបចូលប្រើអាចមានដូចខាងក្រោម

ប្រសិនបើចាំបាច់ត្រូវបើកឯកសារក្នុងរបៀបគោលពីរ នោះអក្សរ b ត្រូវបានបន្ថែមទៅចុងបន្ទាត់ ឧទាហរណ៍ “rb”, “wb”, “ab” ឬសម្រាប់របៀបចម្រុះ “ab+”, “ wb+”, “ab+”។ ជំនួសឱ្យ b អ្នកអាចបន្ថែមអក្សរ t បន្ទាប់មកឯកសារនឹងបើកក្នុងរបៀបអត្ថបទ។ វាអាស្រ័យលើការអនុវត្ត។ នៅក្នុងស្តង់ដារ C ថ្មី (2011) អក្សរ x មានន័យថា fopen គួរតែបរាជ័យប្រសិនបើឯកសារមានរួចហើយ។ ចូរបំពេញបន្ថែមកម្មវិធីចាស់របស់យើង៖ បើកឯកសារឡើងវិញ ហើយពិចារណាពីអ្វីដែលយើងបានសរសេរនៅទីនោះ។

# រួមបញ្ចូល # រួមបញ្ចូល # រួមបញ្ចូល void main() ( FILE *file; char buffer; file = fopen("C:/c/test.txt", "w"); fprintf(file, "Hello, World!"); fclose(file); file = fopen("C:/c/test.txt", "r"); fgets(buffer, 127, file);

ជំនួសឱ្យមុខងារ fgets អ្នកអាចប្រើ fscanf ប៉ុន្តែអ្នកត្រូវចាំថាវាអាចអានបានត្រឹមតែចន្លោះដំបូងប៉ុណ្ណោះ។
fscanf(ឯកសារ, "%127s", សតិបណ្ដោះអាសន្ន);

ដូចគ្នានេះផងដែរជំនួសឱ្យការបើកនិងបិទឯកសារអ្នកអាចប្រើមុខងារ freopen ដែល "បើកឡើងវិញ" ឯកសារជាមួយនឹងសិទ្ធិចូលប្រើថ្មី។

# រួមបញ្ចូល # រួមបញ្ចូល # រួមបញ្ចូល void main() ( FILE *file; char buffer; file = fopen("C:/c/test.txt", "w"); fprintf(file, "Hello, World!"); freopen("C:/ c/test.txt", "r", file); fgets(buffer, 127, file); printf("%s", buffer); fclose(file); getch(); )

មុខងារ fprintf និង fscanf ខុសពី printf និង scanf តែនៅក្នុងនោះពួកគេយកជាអាគុយម៉ង់ដំបូងរបស់ពួកគេនូវទ្រនិចទៅឯកសារដែលពួកគេនឹងបញ្ចេញ ឬពីអ្វីដែលពួកគេនឹងអានទិន្នន័យ។ វាមានតម្លៃបន្ថែមភ្លាមៗថាមុខងារ printf និង scanf អាចត្រូវបានជំនួសយ៉ាងងាយស្រួលដោយមុខងារ fprintf និង fscanf ។ នៅក្នុងប្រព័ន្ធប្រតិបត្តិការ (យើងកំពុងពិចារណាលើប្រព័ន្ធប្រតិបត្តិការធម្មតាបំផុត និងគ្រប់គ្រាន់) មានស្ទ្រីមស្តង់ដារចំនួនបី៖ ស្ទ្រីមទិន្នផលស្តង់ដារ stdout ស្ទ្រីមបញ្ចូលស្តង់ដារ stdin និងស្ទ្រីមលទ្ធផលកំហុសស្តង់ដារ stderr ។ ពួកវាត្រូវបានបើកដោយស្វ័យប្រវត្តិនៅពេលដែលកម្មវិធីត្រូវបានបើកដំណើរការ ហើយត្រូវបានភ្ជាប់ជាមួយកុងសូល។ ឧទាហរណ៍

# រួមបញ្ចូល # រួមបញ្ចូល # រួមបញ្ចូល void main() ( int a, b; fprintf(stdout, "បញ្ចូលលេខពីរ\n"); fscanf(stdin, "%d", &a); fscanf(stdin, "%d", &b); ប្រសិនបើ (b == 0) ( fprintf(stderr, "កំហុស៖ ចែកដោយសូន្យ"); ) else ( fprintf(stdout, "%3f", (float) a / (float) b); ) getch();

កំហុសក្នុងការបើកឯកសារ

ប្រសិនបើការហៅមុខងារ fopen បរាជ័យ វានឹងត្រឡប់ NULL វិញ។ កំហុសនៅពេលធ្វើការជាមួយឯកសារកើតឡើងជាញឹកញាប់ ដូច្នេះរាល់ពេលដែលយើងបើកឯកសារ យើងត្រូវពិនិត្យមើលលទ្ធផលការងារ

# រួមបញ្ចូល # រួមបញ្ចូល # រួមបញ្ចូល #define ERROR_OPEN_FILE -3 void main() ( FILE *file; char buffer; file = fopen("C:/c/test.txt", "w"); if (file == NULL) ( printf("កំហុសក្នុងការបើក ឯកសារ"); getch(); ចេញ(ERROR_OPEN_FILE); ) fprintf(ឯកសារ "ជំរាបសួរពិភពលោក!"); freopen("C:/c/test.txt", "r", ឯកសារ); ប្រសិនបើ (ឯកសារ = = NULL) ( printf("កំហុសក្នុងការបើកឯកសារ"); getch(); exit(ERROR_OPEN_FILE); ) fgets(buffer, 127, file) printf("%s", buffer(file); )

បញ្ហាកើតឡើងនៅពេលដែលឯកសារជាច្រើនត្រូវបានបើកក្នុងពេលតែមួយ៖ ប្រសិនបើមួយក្នុងចំណោមពួកវាមិនអាចបើកបានទេនោះឯកសារដែលនៅសល់ក៏ត្រូវបិទផងដែរ។

ឯកសារ *inputFile, *outputFile; មិនបានចុះហត្ថលេខា m, n; មិនបានចុះហត្ថលេខា i, j; inputFile = fopen(INPUT_FILE, READ_ONLY); ប្រសិនបើ (inputFile == NULL) ( printf("កំហុសក្នុងការបើកឯកសារ %s", INPUT_FILE); getch(); exit(3); ) outputFile = fopen(OUTPUT_FILE, WRITE_ONLY); if (outputFile == NULL) ( printf("កំហុសក្នុងការបើកឯកសារ %s", OUTPUT_FILE); getch(); if (inputFile != NULL) ( fclose(inputFile); ) exit(4); ) ...

ក្នុង​ករណី​សាមញ្ញ អ្នក​អាច​ធ្វើ​ជា​ប្រធាន​ដូច​ក្នុង​លេខ​កូដ​មុន​។ ក្នុងករណីដែលស្មុគ្រស្មាញជាងនេះ វិធីសាស្ត្រត្រូវបានប្រើដែលជំនួស RAII ពី C ++: wrappers ឬ compiler features (cleanup in GCC) ជាដើម។

ការផ្ទុកទិន្នន័យ

ដូចដែលបានរៀបរាប់ខាងលើ នៅពេលដែលយើងបញ្ចេញទិន្នន័យ វាត្រូវបានដាក់ដំបូងនៅក្នុងសតិបណ្ដោះអាសន្ន។ សតិបណ្ដោះអាសន្នត្រូវបានសម្អាត

• 1) ប្រសិនបើវាពេញ
• 2) ប្រសិនបើស្ទ្រីមត្រូវបានបិទ
• 3) ប្រសិនបើយើងបង្ហាញយ៉ាងច្បាស់ថាវាចាំបាច់ដើម្បីជម្រះសតិបណ្ដោះអាសន្ន (មានករណីលើកលែងនៅទីនេះផងដែរ :)) ។
• 4) ជម្រះផងដែរប្រសិនបើកម្មវិធីបានបញ្ចប់ដោយជោគជ័យ។ ក្នុងពេលជាមួយគ្នានោះឯកសារទាំងអស់ត្រូវបានបិទ។ ក្នុងករណីមានកំហុសពេលរត់ វាប្រហែលជាមិនកើតឡើងទេ។

អ្នក​អាច​បង្ខំ​មិន​ផ្ទុក​សតិបណ្ដោះអាសន្ន​ដោយ​ហៅ​មុខងារ fflush(File *)។ សូមក្រឡេកមើលឧទាហរណ៍ពីរ - ដោយមាននិងគ្មានការសម្អាត។

# រួមបញ្ចូល # រួមបញ្ចូល # រួមបញ្ចូល void main() ( FILE *file; char c; file = fopen("C:/c/test.txt", "w"); do ( c = getch(); fprintf(file, "%c", c ); fprintf(stdout, "%c", c //fflush(ឯកសារ);

មិនបញ្ចេញមតិលើការហៅចេញ។ នៅពេលដំណើរការ សូមបើកឯកសារអត្ថបទ ហើយមើលឥរិយាបថ។

អ្នកអាចកំណត់បណ្តុំឯកសារដោយខ្លួនឯងដោយកំណត់ទំហំផ្ទាល់ខ្លួនរបស់អ្នក។ នេះត្រូវបានធ្វើដោយប្រើមុខងារ

Setbuf (ឯកសារ * ស្ទ្រីម, char * buffer);

ដែលយកឯកសារដែលបានបើករួចហើយ និងទ្រនិចទៅសតិបណ្ដោះអាសន្នថ្មី។ ទំហំនៃបណ្តុំថ្មីត្រូវតែមិនតិចជាង BUFSIZ (ឧទាហរណ៍នៅលើស្ថានីយការងារបច្ចុប្បន្ន BUFSIZ គឺ 512 បៃ)។ ប្រសិនបើអ្នកឆ្លងកាត់ NULL ជាបណ្ដោះអាសន្ន នោះស្ទ្រីមនឹងមិនមានសតិបណ្ដោះអាសន្នទេ។ អ្នកក៏អាចប្រើមុខងារបានដែរ។

Int setvbuf(FILE * stream, char * buffer, int mode, size_t size);

ដែលទទួលយកបណ្តុំនៃទំហំទំហំបំពាន។ របៀបអាចយកតម្លៃដូចខាងក្រោម

• _IOFBF- ផ្ទុកពេញ។ ទិន្នន័យត្រូវបានសរសេរទៅឯកសារនៅពេលវាពេញ។ នៅពេលអាន សតិបណ្ដោះអាសន្នត្រូវបានចាត់ទុកថាពេញ នៅពេលដែលប្រតិបត្តិការបញ្ចូលត្រូវបានស្នើសុំ ហើយសតិបណ្ដោះអាសន្នគឺទទេ។
• _IOLBF- សតិបណ្ដោះអាសន្នលីនេអ៊ែរ។ ទិន្នន័យ​ត្រូវ​បាន​សរសេរ​ទៅ​ឯកសារ​នៅ​ពេល​ដែល​វា​ពេញ​ឬ​ពេល​ដែល​មាន​តួអក្សរ​បន្ទាត់​ថ្មី។ នៅពេលអាន សតិបណ្ដោះអាសន្នត្រូវបានបំពេញទៅតួអក្សរបន្ទាត់ថ្មី នៅពេលដែលប្រតិបត្តិការបញ្ចូលត្រូវបានស្នើសុំ ហើយសតិបណ្ដោះអាសន្នគឺទទេ។
• _IONBF- គ្មានការផ្អាក។ ក្នុងករណីនេះ ទំហំ និងប៉ារ៉ាម៉ែត្រសតិបណ្ដោះអាសន្នមិនត្រូវបានអើពើ។

ឧទាហរណ៍៖ ចូរយើងកំណត់សតិបណ្ដោះអាសន្នរបស់យើង ហើយមើលពីរបៀបដែលការអានឯកសារត្រូវបានអនុវត្ត។ សូមឱ្យឯកសារខ្លី (អ្វីមួយដូចជា Hello, World!) ហើយយើងអានវាតាមតួអក្សរ

# រួមបញ្ចូល # រួមបញ្ចូល # រួមបញ្ចូល void main() ( FILE *input = NULL; char c; char buffer = (0); input = fopen("D:/c/text.txt", "rt"); setbuf(input, buffer); while ( !feof(បញ្ចូល)) ( c = fgetc(បញ្ចូល); printf("%c\n", c); printf("%s\n", buffer); _getch(); ) fclose(បញ្ចូល)

វាអាចត្រូវបានគេមើលឃើញថាទិន្នន័យមានរួចហើយនៅក្នុងសតិបណ្ដោះអាសន្ន។ ការអានតួអក្សរតាមតួអក្សរត្រូវបានធ្វើពីសតិបណ្ដោះអាសន្ន។

feof

មុខងារ int feof (ឯកសារ * ស្ទ្រីម); ត្រឡប់ពិតប្រសិនបើចុងបញ្ចប់នៃឯកសារត្រូវបានឈានដល់។ មុខងារនេះងាយស្រួលប្រើនៅពេលដែលអ្នកត្រូវឆ្លងកាត់ឯកសារទាំងមូលពីដើមដល់ចប់។ សូមឱ្យមានឯកសារដែលមានមាតិកាអត្ថបទ text.txt ។ យើងអានឯកសារតាមតួអក្សរ ហើយបង្ហាញវានៅលើអេក្រង់។

# រួមបញ្ចូល # រួមបញ្ចូល # រួមបញ្ចូល void main() ( FILE *input = NULL; char c; input = fopen("D:/c/text.txt", "rt"); ប្រសិនបើ (បញ្ចូល == NULL) ( printf("កំហុសក្នុងការបើកឯកសារ") ; _getch(); ចេញ(0); ខណៈពេល (!feof(បញ្ចូល)) (c = fgetc(បញ្ចូល); fprintf(stdout, "%c", c); ) fclose(បញ្ចូល());

អ្វីគ្រប់យ៉ាងនឹងល្អ ប៉ុន្តែមុខងារ feof មិនដំណើរការត្រឹមត្រូវ... នេះគឺដោយសារតែការពិតដែលថាគំនិតនៃ "ចុងបញ្ចប់នៃឯកសារ" មិនត្រូវបានកំណត់។ កំហុសដែលជារឿយៗកើតឡើងនៅពេលប្រើ feof គឺថាទិន្នន័យចុងក្រោយដែលបានអានត្រូវបានបោះពុម្ពពីរដង។ នេះគឺដោយសារតែការពិតដែលថាទិន្នន័យត្រូវបានសរសេរទៅសតិបណ្ដោះអាសន្នបញ្ចូល ការអានចុងក្រោយកើតឡើងដោយមានកំហុស ហើយមុខងារត្រឡប់តម្លៃចាស់ដែលបានអាន។

# រួមបញ្ចូល # រួមបញ្ចូល # រួមបញ្ចូល void main() ( FILE *input = NULL; char c; input = fopen("D:/c/text.txt", "rt"); ប្រសិនបើ (បញ្ចូល == NULL) ( printf("កំហុសក្នុងការបើកឯកសារ") ; _getch(); ចេញ(0); ខណៈពេល (!feof(បញ្ចូល)) (fscanf(បញ្ចូល, "%c", &c); fprintf(stdout, "%c", c); ) fclose(បញ្ចូល); ();

ឧទាហរណ៍នេះនឹងបរាជ័យ (ភាគច្រើនទំនងជា) ហើយបោះពុម្ពតួអក្សរចុងក្រោយនៃឯកសារពីរដង។

ដំណោះស្រាយគឺមិនត្រូវប្រើ feof ទេ។ ឧទាហរណ៍ រក្សាទុកចំនួនសរុបនៃកំណត់ត្រា ឬប្រើការពិតដែលថាមុខងារ fscanf ។ល។ ជាធម្មតាត្រឡប់ចំនួនតម្លៃដែលបានអាន និងត្រូវគ្នាយ៉ាងត្រឹមត្រូវ។

# រួមបញ្ចូល # រួមបញ្ចូល # រួមបញ្ចូល void main() ( FILE *input = NULL; char c; input = fopen("D:/c/text.txt", "rt"); ប្រសិនបើ (បញ្ចូល == NULL) ( printf("កំហុសក្នុងការបើកឯកសារ") ; _getch(); ចេញ(0); ខណៈពេល (fscanf(បញ្ចូល, "%c", &c) == 1) ( fprintf(stdout, "%c", c);

ឧទាហរណ៍

1. ឯកសារមួយមានលេខពីរ - វិមាត្រនៃអារេ។ ចូរបំពេញឯកសារទីពីរដោយអារេនៃលេខចៃដន្យ។

# រួមបញ្ចូល # រួមបញ្ចូល # រួមបញ្ចូល # រួមបញ្ចូល // ឈ្មោះឯកសារ និងការអនុញ្ញាត #define INPUT_FILE "D:/c/input.txt" #define OUTPUT_FILE "D:/c/output.txt" #define READ_ONLY "r" #define WRITE_ONLY "w" // តម្លៃអតិបរមាសម្រាប់អារេ ទំហំ #define MAX_DIMENSION 100 // កំហុសពេលបើកឯកសារ #define ERROR_OPEN_FILE -3 void main() ( FILE *inputFile, *outputFile; unsigned m, n; unsigned i, j; inputFile = fopen(INPUT_FILE, READ_ONLY); ប្រសិនបើ ( inputFile == NULL) ( printf("កំហុសក្នុងការបើកឯកសារ %s", INPUT_FILE); getch(); exit(ERROR_OPEN_FILE); ) outputFile = fopen(OUTPUT_FILE, WRITE_ONLY) ប្រសិនបើ (outputFile == NULL) (printf("កំហុស ការបើកឯកសារ %s", OUTPUT_FILE); getch(); // ប្រសិនបើឯកសារអាចត្រូវបានបើកសម្រាប់ការអាន នោះវាត្រូវតែបិទប្រសិនបើ (inputFile != NULL) ( fclose(inputFile); ) ចេញ (ERROR_OPEN_FILE); ) fscanf (inputFile, "%ud %ud", &m, &n); ប្រសិនបើ (m > MAX_DIMENSION) ( m = MAX_DIMENSION; ) if (n > MAX_DIMENSION) ( n = MAX_DIMENSION; ) srand(time(NULL));< n; i++) { for (j = 0; j < m; j++) { fprintf(outputFile, "%8d ", rand()); } fprintf(outputFile, "\n"); } //Закрываем файлы fclose(inputFile); fclose(outputFile); }

2. អ្នកប្រើប្រាស់ចម្លងឯកសារ ហើយជ្រើសរើសរបៀបប្រតិបត្តិការជាមុនសិន៖ ឯកសារអាចត្រូវបានបញ្ចេញទៅកុងសូល ឬចម្លងទៅឯកសារថ្មី។

# រួមបញ្ចូល # រួមបញ្ចូល # រួមបញ្ចូល #កំណត់ ERROR_FILE_OPEN -3 void main() ( FILE *origin = NULL; FILE *output = NULL; char filename; int mode; printf("Enter filename:"); scanf("%1023s", filename); origin = fopen (ឈ្មោះឯកសារ "r"); ប្រសិនបើ (ប្រភពដើម == NULL) ( printf("កំហុសក្នុងការបើកឯកសារ %s", ឈ្មោះឯកសារ); getch(); ចេញ(ERROR_FILE_OPEN); ) printf("បញ្ចូលរបៀប៖ "" % d", &mode); ប្រសិនបើ (របៀប == 1) ( printf("បញ្ចូលឈ្មោះឯកសារ៖ "); scanf("%1023s", ឈ្មោះឯកសារ); លទ្ធផល = fopen(ឈ្មោះឯកសារ, "w"); ប្រសិនបើ (លទ្ធផល = = NULL ) ( printf("កំហុសក្នុងការបើកឯកសារ %s", ឈ្មោះឯកសារ); getch(); fclose(ប្រភពដើម); ចេញ(ERROR_FILE_OPEN); ) ) else ( output = stdout; ) ខណៈពេលដែល (!feof(origin)) (fprintf (លទ្ធផល , "%c", fgetc(ប្រភពដើម));

3. អ្នកប្រើប្រាស់បញ្ចូលទិន្នន័យពីកុងសូល ហើយវាត្រូវបានសរសេរទៅឯកសារមួយរហូតដល់គ្រាប់ចុច esc ត្រូវបានចុច។ ពិនិត្យមើលកម្មវិធីហើយមើល។ របៀបដែលវាមានឥរិយាបទប្រសិនបើអ្នកបញ្ចូល backspace: អ្វីដែលជាលទ្ធផលទៅឯកសារ និងអ្វីដែលជាលទ្ធផលទៅកុងសូល។

# រួមបញ្ចូល # រួមបញ្ចូល # រួមបញ្ចូល #define ERROR_FILE_OPEN -3 void main() ( FILE *output = NULL; char c; output = fopen("D:/c/test_output.txt", "w+t"); ប្រសិនបើ (លទ្ធផល == NULL) (printf ("កំហុសក្នុងការបើកឯកសារ"); _getch(); ចេញ(ERROR_FILE_OPEN); , stdout);

4. ឯកសារមានចំនួនគត់។ ស្វែងរកអតិបរមានៃពួកគេ។ ចូរយើងទាញយកប្រយោជន៍ពីការពិតដែលថាមុខងារ fscanf ត្រឡប់ចំនួននៃវត្ថុដែលបានអាន និងផ្គូផ្គងត្រឹមត្រូវ។ លេខ 1 គួរតែត្រលប់មកវិញរាល់ពេល។

# រួមបញ្ចូល # រួមបញ្ចូល # រួមបញ្ចូល #define ERROR_FILE_OPEN -3 void main() ( FILE *input = NULL; int num, maxn, hasRead; input = fopen("D:/c/input.txt", "r"); ប្រសិនបើ (បញ្ចូល == NULL) ( printf("កំហុសក្នុងការបើកឯកសារ"); _getch(); exit(ERROR_FILE_OPEN); ) maxn = INT_MIN; hasRead = 1; if (hasRead != 1) ( បន្ត ; ) if (num >

ដំណោះ​ស្រាយ​មួយ​ទៀត​គឺ​ត្រូវ​អាន​លេខ​រហូត​ដល់​ចប់​ឯកសារ។

# រួមបញ្ចូល # រួមបញ្ចូល # រួមបញ្ចូល # រួមបញ្ចូល #define ERROR_FILE_OPEN -3 void main() ( FILE *input = NULL; int num, maxn, hasRead; input = fopen("D:/c/input.txt", "r"); ប្រសិនបើ (បញ្ចូល == NULL) ( printf("កំហុសក្នុងការបើកឯកសារ"); _getch(); exit(ERROR_FILE_OPEN); ) maxn = INT_MIN; while (!feof(input)) (fscanf(input, "%d", &num); if (num > maxn ) ( maxn = num; ) ) printf("ចំនួនអតិបរមា = %d", maxn);

5. ឯកសារមានពាក្យ៖ ពាក្យរុស្ស៊ី តារាងពាក្យ អង់គ្លេស ក្នុងជួរជាច្រើន។ អ្នក​ប្រើ​បញ្ចូល​ពាក្យ​ជា​ភាសា​អង់គ្លេស​, វា​ជា​ការ​ចាំបាច់​ដើម្បី​ចេញ​ជា​ភាសា​រុស្ស៊ី​។

ឯកសារបកប្រែមើលទៅដូចនេះ

ព្រះអាទិត្យព្រះអាទិត្យ
ខ្មៅដៃ
ខ្មៅដៃប៊ិចប៊ិច
ទ្វារទ្វារ
បង្អួចបង្អួច
កៅអីកៅអី
កៅអី

និងរក្សាទុកនៅក្នុងការអ៊ិនកូដ cp866 (OEM 866) ។ វាសំខាន់ណាស់៖ ពាក្យគូចុងក្រោយក៏បញ្ចប់ដោយបន្ទាត់។

ក្បួនដោះស្រាយមានដូចខាងក្រោម៖ យើងអានបន្ទាត់ពីឯកសារ ស្វែងរកតួអក្សរផ្ទាំងក្នុងបន្ទាត់ ជំនួសតួអក្សរផ្ទាំងដោយលេខសូន្យ ចម្លងពាក្យរុស្ស៊ីពីសតិបណ្ដោះអាសន្ន ចម្លងពាក្យអង់គ្លេសពីសតិបណ្ដោះអាសន្ន ពិនិត្យមើលសមភាព។

# រួមបញ្ចូល # រួមបញ្ចូល # រួមបញ្ចូល # រួមបញ្ចូល #define ERROR_FILE_OPEN -3 void main() ( FILE *input = NULL; char buffer; char enWord; char ruWord; char usrWord; unsigned index; int length; int wasFound; input = fopen("D:/c/input.txt ", "r"); ប្រសិនបើ (បញ្ចូល == NULL) ( printf("កំហុសក្នុងការបើកឯកសារ"); _getch(); exit(ERROR_FILE_OPEN); ) printf("បញ្ចូលពាក្យ៖ "); fgets(usrWord, 127, stdin ); wasFound = 0; while (!feof(បញ្ចូល)) ( fgets(buffer, 511, input); length = strlen(buffer); សម្រាប់ (index = 0; index< length; index++) { if (buffer == "\t") { buffer = "\0"; break; } } strcpy(ruWord, buffer); strcpy(enWord, &buffer); if (!strcmp(enWord, usrWord)) { wasFound = 1; break; } } if (wasFound) { printf("%s", ruWord); } else { printf("Word not found"); } fclose(input); _getch(); }

6. រាប់ចំនួនបន្ទាត់ក្នុងឯកសារ។ យើងនឹងអានតួអក្សរឯកសារតាមតួអក្សរ ដោយរាប់ចំនួនតួអក្សរ "\n" រហូតដល់យើងជួបតួអក្សរ EOF ។ EOF គឺជាតួអក្សរពិសេសដែលបង្ហាញថាការបញ្ចូលបានបញ្ចប់ ហើយមិនមានទិន្នន័យដែលត្រូវអានទៀតទេ។ អនុគមន៍ត្រឡប់តម្លៃអវិជ្ជមានក្នុងករណីមានកំហុស។
ចំណាំ៖ EOF គឺជាប្រភេទ int ដូច្នេះអ្នកត្រូវប្រើ int ដើម្បីអានតួអក្សរ។ លើសពីនេះទៀតតម្លៃនៃ EOF មិនត្រូវបានកំណត់ដោយស្តង់ដារទេ។

#កំណត់ _CRT_SECURE_NO_WARNINGS #រួមបញ្ចូល # រួមបញ្ចូល # រួមបញ្ចូល int cntLines(const char *filename) ( int lines = 0; int any; // ណាមួយគឺជាប្រភេទ int ព្រោះ EOF គឺជាប្រភេទ int! FILE *f = fopen(filename, "r"); ប្រសិនបើ (f == NULL ) (ត្រឡប់ -1; ) ធ្វើ (ណាមួយ = fgetc(f); //printf("%c", ណាមួយ);// បំបាត់កំហុសប្រសិនបើ (ណាមួយ == "\n") (បន្ទាត់ ++; ) ) ខណៈពេលដែល (ណាមួយ ! =EOF ​​fclose(f);

Ru-Cyrl 18- ការបង្រៀន Sypachev S.S. ១៩៨៩-០៤-១៤ [អ៊ីមែលការពារ]លោក Stepan Sypachevសិស្ស

នៅតែមិនច្បាស់? - សរសេរសំណួរទៅប្រអប់សំបុត្រ

មុខងារ fopen() បើកស្ទ្រីមសម្រាប់ប្រើ ភ្ជាប់ឯកសារជាមួយស្ទ្រីមនោះ ហើយបន្ទាប់មកត្រឡប់ទ្រនិច FILE ទៅស្ទ្រីមនោះ។ ភាគច្រើនជាញឹកញាប់ឯកសារត្រូវបានចាត់ទុកជាឯកសារឌីស។ មុខងារ fopen() មានគំរូដូចខាងក្រោម៖

ឯកសារ *fopen(const char *filename, const char *mode);

កន្លែងដែលរបៀបចង្អុលទៅខ្សែអក្សរដែលមានរបៀបដែលចង់បានសម្រាប់បើកឯកសារ។ តម្លៃត្រឹមត្រូវសម្រាប់របៀបក្នុង Borland C++ ត្រូវបានបង្ហាញក្នុងតារាង។ ឈ្មោះឯកសារត្រូវតែជាខ្សែអក្សរដែលផ្តល់ឈ្មោះឯកសារត្រឹមត្រូវដល់ប្រព័ន្ធប្រតិបត្តិការ ហើយអាចមានឈ្មោះផ្លូវ។

មុខងារ fopen() ត្រឡប់ទ្រនិចទៅប្រភេទមូលដ្ឋាន FILE ។ ទ្រនិចនេះកំណត់អត្តសញ្ញាណឯកសារ និងត្រូវបានប្រើប្រាស់ដោយមុខងារប្រព័ន្ធឯកសារភាគច្រើន។ អ្នកមិនគួរផ្លាស់ប្តូរវាដោយខ្លួនឯងទេ។ អនុគមន៍​ត្រឡប់​ទ្រនិច​ទទេ ប្រសិនបើ​ឯកសារ​មិន​អាច​បើក​បាន។

ដូចដែលតារាងបង្ហាញ ឯកសារអាចត្រូវបានបើកជាអត្ថបទ ឬរបៀបប្រព័ន្ធគោលពីរ។ នៅក្នុងទម្រង់អត្ថបទ ដូចដែលអ្នកវាយបញ្ចូល លំដាប់នៃការបញ្ជូនត្រឡប់មកវិញ និងព័ត៌មានបន្ទាត់ត្រូវបានបកប្រែទៅជាតួអក្សរបន្ទាត់ថ្មី។ នៅក្នុងលទ្ធផល ភាពផ្ទុយគ្នាគឺជាការពិត៖ តួអក្សរបន្ទាត់ថ្មីត្រូវបានបកប្រែទៅជាការបញ្ជូនត្រឡប់មកវិញ និងព័ត៌មានបន្ទាត់។ ការបកប្រែនេះមិនកើតឡើងនៅក្នុងឯកសារគោលពីរទេ។ នៅពេលដែលទាំង t ឬ b មិនត្រូវបានបញ្ជាក់នៅក្នុងអាគុយម៉ង់របៀប នោះស្ថានភាពអត្ថបទ/ប្រព័ន្ធគោលពីររបស់ឯកសារត្រូវបានកំណត់ដោយតម្លៃនៃអថេរសកល _fmode ដែលបានកំណត់នៅក្នុង Borland C++ ។ តាមលំនាំដើម fmode ត្រូវបានកំណត់ទៅ O_TEXT នោះគឺ របៀបអត្ថបទត្រូវបានកំណត់។ ប្រសិនបើអ្នកកំណត់ _fmode ទៅ O_BINARY នោះឯកសារនឹងត្រូវបានបើកក្នុងរបៀបគោលពីរ។ (ម៉ាក្រូទាំងនេះត្រូវបានកំណត់ក្នុង fcntl.h.) តាមធម្មជាតិ ការប្រើ t ឬ b ច្បាស់លាស់លុបបំបាត់ផលប៉ះពាល់ដែលទាក់ទងនឹងអថេរ _fmode ។ លើសពីនេះទៀត _fmode គឺជាក់លាក់ចំពោះផលិតផល Borland ប៉ុណ្ណោះ។ វាមិនត្រូវបានកំណត់នៅក្នុងប្រព័ន្ធ ANSI C I/O ទេ។

ប្រសិនបើអ្នកត្រូវការបើកឯកសារដែលមានឈ្មោះតេស្តសម្រាប់ការសរសេរ អ្នកគួរតែសរសេរ៖

Fp = fopen("សាកល្បង", "w");

ដែល fp គឺជាអថេរនៃប្រភេទ FILE * ។ ទោះយ៉ាងណាក៏ដោយ វាជារឿងធម្មតាដែលឃើញដូចខាងក្រោម៖

ប្រសិនបើ((fp = fopen("test", "w"))==NULL) (
puts("មិនអាចបើកឯកសារ។");
ច្រកចេញ (1);
}

វិធីសាស្រ្តនេះអនុញ្ញាតឱ្យអ្នករកឃើញកំហុសនៅពេលបើកឯកសារឧទាហរណ៍វត្តមាននៃការការពារការសរសេរឬកង្វះទំហំទំនេរនៅលើថាស។

ប្រសិនបើ fopen() ត្រូវបានប្រើដើម្បីបើកឯកសារសម្រាប់ការសរសេរ នោះឯកសារដែលមានពីមុនដែលមានឈ្មោះជាក់លាក់នឹងត្រូវបានលុប។ ប្រសិនបើឯកសារដែលមានឈ្មោះដែលបានបញ្ជាក់មិនមានទេ វានឹងត្រូវបានបង្កើត។

ប្រសិនបើអ្នកត្រូវការបន្ថែមព័ត៌មានទៅចុងបញ្ចប់នៃឯកសារ អ្នកគួរតែប្រើរបៀប a (បន្ថែម)។ ប្រសិនបើឯកសារមិនមានទេនោះវានឹងត្រូវបានបង្កើត។

ការបើកឯកសារសម្រាប់ការអានតម្រូវឱ្យមានវត្តមាននៃឯកសារ។ ប្រសិនបើឯកសារមិនមានទេ កំហុសមួយនឹងត្រូវបានត្រឡប់។ ប្រសិនបើឯកសារត្រូវបានបើកសម្រាប់ប្រតិបត្តិការអាន/សរសេរ នោះវាមិនត្រូវបានលុបទេប្រសិនបើវាមាន ហើយប្រសិនបើឯកសារមិនមាន នោះវាត្រូវបានបង្កើត។

ដើម្បីភាពងាយស្រួល ព័ត៌មាននៅក្នុងឧបករណ៍ផ្ទុកត្រូវបានរក្សាទុកក្នុងទម្រង់ជាឯកសារ។

ឯកសារគឺជាតំបន់ដែលមានឈ្មោះនៃអង្គចងចាំខាងក្រៅដែលបានបម្រុងទុកសម្រាប់រក្សាទុកអារេនៃទិន្នន័យ។ ទិន្នន័យដែលមាននៅក្នុងឯកសារមានលក្ខណៈចម្រុះណាស់៖ កម្មវិធីក្នុងក្បួនដោះស្រាយ ឬភាសាម៉ាស៊ីន។ ទិន្នន័យដំបូងសម្រាប់ប្រតិបត្តិការកម្មវិធី ឬលទ្ធផលនៃការអនុវត្តកម្មវិធី; អត្ថបទឥតគិតថ្លៃ; រូបភាពក្រាហ្វិកជាដើម។

ថតឯកសារ (ថតឯកសារ) - បណ្តុំនៃបៃដែលមានឈ្មោះនៅលើឧបករណ៍ផ្ទុកដែលមានឈ្មោះនៃថតរង និងឯកសារ ដែលប្រើក្នុងប្រព័ន្ធឯកសារ ដើម្បីសម្រួលដល់ការរៀបចំឯកសារ។

ប្រព័ន្ធ​ឯកសារហៅថាផ្នែកមុខងារនៃប្រព័ន្ធប្រតិបត្តិការដែលធ្វើប្រតិបត្តិការលើឯកសារ។ ឧទាហរណ៍នៃប្រព័ន្ធឯកសារគឺ FAT (FAT - តារាងបែងចែកឯកសារ), NTFS, UDF (ប្រើនៅលើស៊ីឌី) ។

មានកំណែសំខាន់ៗចំនួនបីនៃ FAT គឺ FAT12 FAT16 និង FAT32 ។ ពួកវាខុសគ្នានៅក្នុងជម្រៅប៊ីតនៃកំណត់ត្រានៅក្នុងរចនាសម្ព័ន្ធថាស ពោលគឺឧ។ ចំនួនប៊ីតដែលបានបែងចែកដើម្បីរក្សាទុកលេខចង្កោម។ FAT12 ត្រូវបានប្រើជាចម្បងសម្រាប់ថាសទន់ (រហូតដល់ 4 KB) FAT16 - សម្រាប់ថាសដែលមានសមត្ថភាពតូច FAT32 - សម្រាប់ដ្រាយ FLASH ដែលមានសមត្ថភាពខ្ពស់ (រហូតដល់ 32 GB) ។

សូមក្រឡេកមើលរចនាសម្ព័ន្ធនៃប្រព័ន្ធឯកសារដោយប្រើ FAT32 ជាឧទាហរណ៍។

រចនាសម្ព័ន្ធឯកសារ FAT32

ឧបករណ៍អង្គចងចាំខាងក្រៅនៅក្នុងប្រព័ន្ធ FAT32 មានអាសយដ្ឋានប្លុកជាជាងអាសយដ្ឋានបៃ។ ព័ត៌មានត្រូវបានសរសេរទៅឧបករណ៍អង្គចងចាំខាងក្រៅនៅក្នុងប្លុក ឬផ្នែក។

វិស័យគឺជាអង្គភាពផ្ទុកព័ត៌មានដែលអាចអាសយដ្ឋានបានអប្បបរមានៅលើឧបករណ៍ផ្ទុកខាងក្រៅ។ ជាធម្មតា ទំហំផ្នែកត្រូវបានជួសជុលនៅ 512 បៃ។ ដើម្បីបង្កើនទំហំអាសយដ្ឋាននៃឧបករណ៍អង្គចងចាំខាងក្រៅ វិស័យត្រូវបានបញ្ចូលគ្នាជាក្រុមដែលហៅថាចង្កោម។

ចង្កោមគឺជាសហជីពនៃវិស័យជាច្រើន ដែលអាចចាត់ទុកថាជាអង្គភាពឯករាជ្យដែលមានលក្ខណៈសម្បត្តិជាក់លាក់។ ទ្រព្យសម្បត្តិសំខាន់នៃចង្កោមគឺទំហំរបស់វា វាស់ជាចំនួនផ្នែក ឬចំនួនបៃ។

ប្រព័ន្ធឯកសារ FAT32 មានរចនាសម្ព័ន្ធដូចខាងក្រោម។

ចង្កោមដែលប្រើសម្រាប់ការសរសេរឯកសារត្រូវបានដាក់លេខដោយចាប់ផ្តើមពីលេខ 2។ តាមក្បួន ចង្កោមលេខ 2 ត្រូវបានប្រើដោយថតឫស ហើយចាប់ផ្តើមពីចង្កោមលេខ 3 អារេទិន្នន័យត្រូវបានរក្សាទុក។ វិស័យដែលប្រើដើម្បីរក្សាទុកព័ត៌មាននៅខាងលើថតឫសមិនត្រូវបានចង្កោមទេ។
ទំហំឯកសារអប្បបរមាដែលត្រូវការនៅលើថាសត្រូវគ្នានឹង 1 ចង្កោម។

ផ្នែកចាប់ផ្ដើមចាប់ផ្តើមដោយព័ត៌មានខាងក្រោម៖

• EB 58 90 - លោតដោយគ្មានលក្ខខណ្ឌ និងហត្ថលេខា;
• 4D 53 44 4F 53 35 2E 30 MSDOS5.0;
• 00 02 - ចំនួនបៃក្នុងវិស័យ (ជាធម្មតា 512);
• 1 បៃ - ចំនួននៃផ្នែកនៅក្នុងចង្កោម;
• 2 បៃ - ចំនួននៃផ្នែកបម្រុង។

លើសពីនេះ ផ្នែកចាប់ផ្ដើមមានព័ត៌មានសំខាន់ៗដូចខាងក្រោម៖

• 0x10 (1 បៃ) - ចំនួនតារាង FAT (ជាធម្មតា 2);
• 0x20 (4 បៃ) - ចំនួននៃផ្នែកនៅលើថាស;
• 0x2С (4 បៃ) - ចំនួនចង្កោមនៃថតឫស;
• 0x47 (11 បៃ) - ស្លាកកម្រិតសំឡេង;
• 0x1FE (2 បៃ) - ហត្ថលេខាផ្នែកចាប់ផ្ដើម (55 AA) ។

ផ្នែកព័ត៌មានប្រព័ន្ធឯកសារមាន៖

• 0x00 (4 បៃ) - ហត្ថលេខា (52 52 61 41);
• 0x1E4 (4 បៃ) - ហត្ថលេខា (72 72 41 61);
• 0x1E8 (4 បៃ) - ចំនួននៃចង្កោមឥតគិតថ្លៃ, -1 ប្រសិនបើមិនស្គាល់;
• 0x1EC (4 បៃ) - ចំនួននៃចង្កោមដែលបានកត់ត្រាចុងក្រោយ;
• 0x1FE (2 បៃ) - ហត្ថលេខា (55 AA) ។

តារាង FAT មានព័ត៌មានអំពីស្ថានភាពនៃចង្កោមនីមួយៗនៅលើថាស។ 2 បៃទាបនៃតារាង FAT រក្សាទុក F8 FF FF 0F FF FF FF FF FF (ដែលត្រូវនឹងស្ថានភាពនៃចង្កោម 0 និង 1 ដែលអវត្តមានរាងកាយ) ។ បន្ទាប់មក ស្ថានភាពនៃចង្កោមនីមួយៗមានចំនួននៃចង្កោមដែលឯកសារបច្ចុប្បន្នបន្ត ឬព័ត៌មានខាងក្រោម៖

• 00 00 00 00 - ចង្កោមគឺឥតគិតថ្លៃ;
• FF FF FF 0F - ចុងបញ្ចប់នៃឯកសារបច្ចុប្បន្ន។

• 8 បៃ - ឈ្មោះឯកសារ;
• 3 បៃ - ផ្នែកបន្ថែមឯកសារ;

ថត root មានសំណុំនៃកំណត់ត្រាព័ត៌មាន 32 ប៊ីតអំពីឯកសារនីមួយៗដែលមានព័ត៌មានដូចខាងក្រោមៈ

នៅពេលធ្វើការជាមួយឈ្មោះឯកសារវែង (រួមទាំងឈ្មោះរុស្ស៊ី) ឈ្មោះឯកសារត្រូវបានអ៊ិនកូដដោយប្រើប្រព័ន្ធអ៊ិនកូដ UTF-16 ។ ក្នុងករណីនេះ 2 បៃត្រូវបានបម្រុងទុកសម្រាប់ការអ៊ិនកូដតួអក្សរនីមួយៗ។ ក្នុងករណីនេះ ឈ្មោះឯកសារត្រូវបានសរសេរក្នុងរចនាសម្ព័ន្ធដូចខាងក្រោមៈ

• 1 បៃលំដាប់;
• 10 បៃមានតួអក្សរ 5 ទាបនៃឈ្មោះឯកសារ។
• គុណលក្ខណៈ 1 បៃ;
• 1 បៃបានបម្រុងទុក;
• 1 បៃ - ឈ្មោះ DOS checksum;
• 12 បៃមានតួអក្សរ 3 ទាបនៃឈ្មោះឯកសារ។
• 2 បៃ - ចំនួននៃចង្កោមដំបូង;
• តួអក្សរដែលនៅសល់នៃឈ្មោះវែង។

ធ្វើការជាមួយឯកសារជាភាសា C

ចំពោះអ្នកសរសេរកម្មវិធី ឯកសារបើកចំហត្រូវបានតំណាងជាលំដាប់នៃទិន្នន័យដែលកំពុងអាន ឬសរសេរ។ នៅពេលដែលឯកសារត្រូវបានបើក វាត្រូវបានភ្ជាប់ជាមួយ ស្ទ្រីម I/O. ព័ត៌មានលទ្ធផលត្រូវបានសរសេរទៅស្ទ្រីម ព័ត៌មានបញ្ចូលត្រូវបានអានពីស្ទ្រីម។

នៅពេលដែលការស្ទ្រីមត្រូវបានបើកសម្រាប់ I/O វាត្រូវបានភ្ជាប់ជាមួយនឹងរចនាសម្ព័ន្ធ FILE ស្តង់ដារ ដែលត្រូវបានកំណត់នៅក្នុង stdio.h ។ រចនាសម្ព័ន្ធ FILE មានព័ត៌មានចាំបាច់អំពីឯកសារ។

ការបើកឯកសារត្រូវបានធ្វើដោយប្រើមុខងារ fopen() ដែលត្រឡប់ទ្រនិចទៅរចនាសម្ព័ន្ធ FILE ដែលអាចត្រូវបានប្រើសម្រាប់ប្រតិបត្តិការជាបន្តបន្ទាប់នៅលើឯកសារ។

ឯកសារ * fopen (ឈ្មោះ, ប្រភេទ);

• "r" - បើកឯកសារសម្រាប់ការអាន (ឯកសារត្រូវតែមាន);
• "w" - បើកឯកសារទទេសម្រាប់ការសរសេរ; ប្រសិនបើឯកសារមាន មាតិការបស់វាត្រូវបានបាត់បង់។
• "a" - បើកឯកសារសម្រាប់ការសរសេរដល់ទីបញ្ចប់ (សម្រាប់បន្ថែម); ឯកសារត្រូវបានបង្កើតប្រសិនបើវាមិនមាន;
• "r+" - បើកឯកសារសម្រាប់អាននិងសរសេរ (ឯកសារត្រូវតែមាន);
• "w+" - បើកឯកសារទទេសម្រាប់អាននិងសរសេរ; ប្រសិនបើឯកសារមាន មាតិការបស់វាត្រូវបានបាត់បង់។
• "a+" - បើកឯកសារសម្រាប់អាន និងបន្ថែម ប្រសិនបើឯកសារមិនមានទេ នោះវាត្រូវបានបង្កើត។

តម្លៃត្រឡប់គឺជាទ្រនិចទៅស្ទ្រីមបើកចំហ។ ប្រសិនបើកំហុសត្រូវបានជួបប្រទះ NULL ត្រូវបានត្រឡប់។

មុខងារ fclose() បិទស្ទ្រីម ឬស្ទ្រីមដែលភ្ជាប់ជាមួយឯកសារដែលបានបើកដោយប្រើមុខងារ fopen()។ ចរន្តដែលត្រូវបិទត្រូវបានកំណត់ដោយអាគុយម៉ង់នៃមុខងារ fclose() ។

តម្លៃត្រឡប់៖ តម្លៃ 0 ប្រសិនបើស្ទ្រីមត្រូវបានបិទដោយជោគជ័យ។ EOF ថេរប្រសិនបើមានកំហុសកើតឡើង។

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# រួមបញ្ចូល
int main()(
ឯកសារ * fp;
ឈ្មោះ char = "my.txt" ;
ប្រសិនបើ ((fp = fopen(ឈ្មោះ "r" )) == NULL)
{
printf( "បរាជ័យក្នុងការបើកឯកសារ");
getchar();
ត្រឡប់ 0;
}
// ជោគជ័យក្នុងការបើកឯកសារ
... // សកម្មភាពដែលត្រូវការលើទិន្នន័យ
fclose(fp);
getchar();
ត្រឡប់ 0;
}

ការអានតួអក្សរពីឯកសារ:

char fgetc (ស្ទ្រីម);

ការសរសេរនិមិត្តសញ្ញាទៅឯកសារ:

fputc (char, ស្ទ្រីម);

អាគុយម៉ង់របស់មុខងារគឺជាតួអក្សរ និងចង្អុលទៅស្ទ្រីមនៃប្រភេទ FILE ។ អនុគមន៍​ត្រឡប់​កូដ​តួអក្សរ​ដែល​បាន​អាន។

មុខងារ fscanf() និង fprintf() គឺស្រដៀងគ្នាទៅនឹងមុខងារ scanf() និង printf() ប៉ុន្តែដំណើរការជាមួយឯកសារទិន្នន័យ និងមានទ្រនិចឯកសារជាអាគុយម៉ង់ដំបូងរបស់ពួកគេ។

fscanf (ស្ទ្រីម "ទម្រង់បញ្ចូល" អាគុយម៉ង់);