ไฟล์ C I/O: สร้าง เปิด อ่าน เขียน และปิดไฟล์

ค การจัดการไฟล์

ไฟล์สามารถใช้เพื่อจัดเก็บข้อมูลปริมาณมากอย่างถาวรได้ เช่นเดียวกับภาษาโปรแกรมอื่นๆ ภาษา 'C' ก็มีระบบการจัดการไฟล์ดังต่อไปนี้ ฟังก์ชั่น,

1. การสร้างไฟล์
2. การเปิดไฟล์
3. กำลังอ่านไฟล์
4. กำลังเขียนลงในไฟล์
5. การปิดไฟล์

ต่อไปนี้เป็นฟังก์ชันการจัดการไฟล์ที่สำคัญที่สุดที่มีอยู่ใน 'C'

วิธีสร้างไฟล์

เมื่อใดก็ตามที่คุณต้องการทำงานกับไฟล์ ขั้นตอนแรกคือการสร้างไฟล์ ไฟล์ไม่มีอะไรนอกจากพื้นที่ในหน่วยความจำที่จัดเก็บข้อมูล

ในการสร้างไฟล์ในโปรแกรม 'C' ให้ใช้รูปแบบต่อไปนี้

FILE *fp;
fp = fopen ("file_name", "mode");

ในรูปแบบข้างต้น ไฟล์คือโครงสร้างข้อมูลที่กำหนดไว้ในไลบรารีมาตรฐาน

fopen เป็นฟังก์ชันมาตรฐานที่ใช้เปิดไฟล์

• หากไม่มีไฟล์อยู่ในระบบ ไฟล์นั้นจะถูกสร้างขึ้นแล้วเปิดขึ้น
• หากไฟล์นั้นมีอยู่แล้วในระบบ ฟังก์ชันนี้จะเปิดไฟล์นั้นโดยตรง

fp คือไฟล์ ตัวชี้ ซึ่งชี้ไปยังไฟล์ประเภท

ทุกครั้งที่คุณเปิดหรือสร้างไฟล์ คุณต้องระบุว่าจะทำอะไรกับไฟล์นั้น ไฟล์ในการเขียนโปรแกรมภาษา C สามารถสร้างหรือเปิดเพื่ออ่าน/เขียนได้ โหมดใช้เพื่อระบุว่าคุณต้องการเปิดไฟล์เพื่อวัตถุประสงค์ใด ๆ ที่ระบุไว้ด้านล่างหรือไม่ ต่อไปนี้คือโหมดประเภทต่าง ๆ ในการเขียนโปรแกรมภาษา C ที่สามารถใช้ได้ขณะทำงานกับไฟล์

ในไวยากรณ์ที่กำหนด ชื่อไฟล์และโหมดจะถูกระบุดังนี้ เงื่อนไข ดังนั้นจึงต้องใส่เครื่องหมายอัญประกาศคู่ล้อมรอบเสมอ

ตัวอย่างเช่น:

#include <stdio.h>
int main() {
FILE *fp;
fp  = fopen ("data.txt", "w");
}

Output:

ไฟล์ถูกสร้างขึ้นในโฟลเดอร์เดียวกับที่คุณบันทึกรหัสของคุณ

คุณสามารถระบุเส้นทางที่คุณต้องการสร้างไฟล์ของคุณได้

#include <stdio.h>
int main() {
FILE *fp;
fp  = fopen ("D://data.txt", "w");
}

วิธีปิดไฟล์

ควรปิดไฟล์ทุกครั้งเมื่อดำเนินการเสร็จสิ้น เนื่องจากเนื้อหาและลิงก์ไปยังไฟล์จะถูกยกเลิก วิธีนี้จะช่วยป้องกันไม่ให้ไฟล์เสียหายโดยไม่ได้ตั้งใจ

'C' มีฟังก์ชัน fclose สำหรับปิดไฟล์ โดยมีรูปแบบคำสั่ง fclose ดังต่อไปนี้

fclose (file_pointer);

ตัวอย่างเช่น:

FILE *fp;
fp  = fopen ("data.txt", "r");
fclose (fp);

ฟังก์ชัน fclose รับตัวชี้ไฟล์เป็นอาร์กิวเมนต์ จากนั้นไฟล์ที่เชื่อมโยงกับตัวชี้ไฟล์นั้นจะถูกปิดด้วยฟังก์ชัน fclose โดยจะส่งคืนค่า 0 หากการปิดไฟล์สำเร็จ และส่งคืนค่า EOF (สิ้นสุดไฟล์) หากเกิดข้อผิดพลาดขณะปิดไฟล์

หลังจากปิดไฟล์แล้ว ตัวชี้ไฟล์เดียวกันยังสามารถใช้กับไฟล์อื่นได้

ในการเขียนโปรแกรม 'C' ไฟล์จะถูกปิดโดยอัตโนมัติเมื่อโปรแกรมถูกยกเลิก การปิดไฟล์ด้วยตนเองโดยการเขียนฟังก์ชัน fclose เป็นแนวทางการเขียนโปรแกรมที่ดี

การเขียนไฟล์

ในภาษา C เมื่อคุณเขียนลงไฟล์ จะต้องเพิ่มอักขระขึ้นบรรทัดใหม่ '\n' อย่างชัดเจน

ไลบรารี stdio มีฟังก์ชันที่จำเป็นในการเขียนลงไฟล์:

• fputc(char, file_pointer): ฟังก์ชันนี้จะเขียนอักขระหนึ่งตัวลงในไฟล์ที่ชี้โดย file_pointer
• fputs(str, file_pointer): ฟังก์ชันนี้เขียนข้อความลงในไฟล์ที่ชี้โดย file_pointer
• fprintf(file_pointer, str, variable_lists): ฟังก์ชันนี้จะพิมพ์ข้อความลงในไฟล์ที่ชี้โดย file_pointer ข้อความนั้นสามารถระบุรูปแบบและรายการตัวแปร variable_lists ได้ (ถ้ามี)

โปรแกรมด้านล่างนี้แสดงวิธีการเขียนลงไฟล์:

fputc() ฟังก์ชั่น:

#include <stdio.h>
int main() {
        int i;
        FILE * fptr;
        char fn[50];
        char str[] = "Guru99 Rocks\n";
        fptr = fopen("fputc_test.txt", "w"); // "w" defines "writing mode"
        for (i = 0; str[i] != '\n'; i++) {
            /* write to file using fputc() function */
            fputc(str[i], fptr);
        }
        fclose(fptr);
        return 0;
    }

Output:

โปรแกรมข้างต้นจะเขียนอักขระทีละตัวลงในไฟล์ fputc_test.txt จนกว่าจะถึงสัญลักษณ์ขึ้นบรรทัดใหม่ “\n” ซึ่งแสดงว่าเขียนประโยคสำเร็จแล้ว กระบวนการคือการนำอักขระแต่ละตัวจากอาร์เรย์มาเขียนลงในไฟล์

1. ในโปรแกรมข้างต้น เราได้สร้างและเปิดไฟล์ชื่อ fputc_test.txt ในโหมดเขียน และประกาศสตริงของเราซึ่งจะถูกเขียนลงในไฟล์
2. เราทำการเขียนทีละอักขระโดยใช้ลูป for และใส่แต่ละตัวอักขระลงในไฟล์จนกว่าจะพบอักขระ "\n" จากนั้นจึงปิดไฟล์โดยใช้ฟังก์ชัน fclose

fputs () ฟังก์ชัน:

#include <stdio.h>
int main() {
        FILE * fp;
        fp = fopen("fputs_test.txt", "w+");
        fputs("This is Guru99 Tutorial on fputs,", fp);
        fputs("We don't need to use for loop\n", fp);
        fputs("Easier than fputc function\n", fp);
        fclose(fp);
        return (0);
    }

Output:

1. ในโปรแกรมข้างต้น เราได้สร้างและเปิดไฟล์ชื่อ fputs_test.txt ในโหมดเขียน
2. หลังจากที่เราทำการเขียนข้อมูลโดยใช้ฟังก์ชัน fputs() โดยเขียนสตริงที่แตกต่างกันสามสตริง
3. จากนั้นไฟล์จะถูกปิดโดยใช้ฟังก์ชัน fclose

fprintf()ฟังก์ชัน:

#include <stdio.h>
    int main() {
        FILE *fptr;
        fptr = fopen("fprintf_test.txt", "w"); // "w" defines "writing mode"
        /* write to file */
        fprintf(fptr, "Learning C with Guru99\n");
        fclose(fptr);
        return 0;
    }

Output:

1. ในโปรแกรมข้างต้นเราได้สร้างและเปิดไฟล์ชื่อ fprintf_test.txt ในโหมดเขียน
2. หลังจากดำเนินการเขียนโดยใช้ฟังก์ชัน fprintf() โดยการเขียนสตริงแล้ว ไฟล์จะถูกปิดโดยใช้ฟังก์ชัน fclose

การอ่านข้อมูลจากไฟล์

มีฟังก์ชันที่แตกต่างกันสามฟังก์ชันสำหรับการอ่านข้อมูลจากไฟล์โดยเฉพาะ

• fgetc(file_pointer): ฟังก์ชันนี้จะส่งคืนอักขระตัวถัดไปจากไฟล์ที่ชี้โดยตัวชี้ไฟล์ เมื่อถึงจุดสิ้นสุดของไฟล์ จะส่งคืนค่า EOF
• fgets(buffer, n, file_pointer): ฟังก์ชันนี้จะอ่านอักขระ n-1 ตัวจากไฟล์และเก็บสตริงไว้ในบัฟเฟอร์ โดยเพิ่มอักขระ NULL '\0' เป็นอักขระสุดท้าย
• fscanf(file_pointer, conversion_specifiers, variable_adresses): ฟังก์ชันนี้ใช้สำหรับแยกวิเคราะห์ข้อมูล โดยจะอ่านอักขระจากไฟล์และกำหนดค่าให้กับลิสต์ของตัวชี้ตัวแปร variable_adresses โดยใช้ตัวระบุการแปลง โปรดจำไว้ว่า เช่นเดียวกับ scanf ฟังก์ชัน fscanf จะหยุดอ่านสตริงเมื่อพบช่องว่างหรือขึ้นบรรทัดใหม่

โปรแกรมต่อไปนี้สาธิตการอ่านจากไฟล์ fputs_test.txt โดยใช้ฟังก์ชัน fgets(),fscanf() และ fgetc() ตามลำดับ:

#include <stdio.h>
int main() {
        FILE * file_pointer;
        char buffer[30], c;

        file_pointer = fopen("fprintf_test.txt", "r");
        printf("----read a line----\n");
        fgets(buffer, 50, file_pointer);
        printf("%s\n", buffer);

        printf("----read and parse data----\n");
        file_pointer = fopen("fprintf_test.txt", "r"); //reset the pointer
        char str1[10], str2[2], str3[20], str4[2];
        fscanf(file_pointer, "%s %s %s %s", str1, str2, str3, str4);
        printf("Read String1 |%s|\n", str1);
        printf("Read String2 |%s|\n", str2);
        printf("Read String3 |%s|\n", str3);
        printf("Read String4 |%s|\n", str4);

        printf("----read the entire file----\n");

        file_pointer = fopen("fprintf_test.txt", "r"); //reset the pointer
        while ((c = getc(file_pointer)) != EOF) printf("%c", c);

        fclose(file_pointer);
        return 0;
    }

ผลลัพธ์:

----read a line----
Learning C with Guru99

----read and parse data----
Read String1 |Learning|
Read String2 |C|
Read String3 |with|
Read String4 |Guru99|
----read the entire file----
Learning C with Guru99

1. ในโปรแกรมข้างต้น เราได้เปิดไฟล์ชื่อ “fprintf_test.txt” ซึ่งเขียนไว้ก่อนหน้านี้โดยใช้ฟังก์ชัน fprintf() และไฟล์นั้นมีเนื้อหาว่า “เรียนรู้ภาษา C ด้วย” Guruสตริงขนาด 99 นิ้ว เราอ่านสตริงนี้โดยใช้ฟังก์ชัน fgets() ซึ่งอ่านทีละบรรทัด โดยขนาดบัฟเฟอร์ต้องเพียงพอที่จะรองรับทั้งบรรทัด
2. เราเปิดไฟล์อีกครั้งเพื่อรีเซ็ตตัวชี้ไฟล์ให้ชี้ไปที่จุดเริ่มต้นของไฟล์ สร้างตัวแปรสตริงต่างๆ เพื่อจัดการแต่ละคำแยกกัน พิมพ์ตัวแปรเพื่อดูเนื้อหา ฟังก์ชัน fscanf() ส่วนใหญ่ใช้เพื่อแสดงผลtracและแยกวิเคราะห์ข้อมูลจากไฟล์
3. เปิดไฟล์อีกครั้งเพื่อรีเซ็ตไฟล์ตัวชี้ให้ชี้ไปที่จุดเริ่มต้นของไฟล์ อ่านข้อมูลและพิมพ์จากไฟล์ทีละอักขระโดยใช้ฟังก์ชัน getc() จนกระทั่งพบคำสั่ง EOF
4. หลังจากดำเนินการอ่านไฟล์โดยใช้ตัวแปรต่างๆ แล้ว เราได้ปิดไฟล์อีกครั้งโดยใช้ฟังก์ชัน fclose

ไฟล์แบบโต้ตอบอ่านและเขียนด้วย getc และ putc

การดำเนินการกับไฟล์เหล่านี้เป็นเรื่องง่ายที่สุด Getc ย่อมาจาก get character และ putc ย่อมาจาก put character ฟังก์ชันทั้งสองนี้ใช้สำหรับจัดการอักขระเพียงตัวเดียวในแต่ละครั้ง

โปรแกรมต่อไปนี้สาธิตฟังก์ชันการจัดการไฟล์ในการเขียนโปรแกรม 'C':

#include <stdio.h>
int main() {
        FILE * fp;
        char c;
        printf("File Handling\n");
        //open a file
        fp = fopen("demo.txt", "w");
        //writing operation
        while ((c = getchar()) != EOF) {
            putc(c, fp);
        }
        //close file
        fclose(fp);
        printf("Data Entered:\n");
        //reading
        fp = fopen("demo.txt", "r");
        while ((c = getc(fp)) != EOF) {
            printf("%c", c);
        }
        fclose(fp);
        return 0;
    }

Output:

1. ในโปรแกรมข้างต้นเราได้สร้างและเปิดไฟล์ที่เรียกว่าการสาธิตในโหมดเขียน
2. หลังจากดำเนินการเขียนแล้ว ไฟล์จะถูกปิดโดยใช้ฟังก์ชัน fclose
3. เราได้เปิดไฟล์อีกครั้งซึ่งขณะนี้มีข้อมูลอยู่ในโหมดอ่าน ลูป while จะทำงานจนกว่าจะพบ eof เมื่อพบจุดสิ้นสุดของไฟล์แล้ว การทำงานจะสิ้นสุดลงและจะแสดงข้อมูลโดยใช้ฟังก์ชัน printf
4. หลังจากดำเนินการอ่านไฟล์จะถูกปิดอีกครั้งโดยใช้ฟังก์ชัน fclose

คำถามที่พบบ่อย