วัตถุประสงค์เชิงพฤติกรรม (Behavioral Objectives)
หลังจากศึกษาจบบทเรียนนี้แล้ว นักศึกษาจะมีความสามารถดังนี้
(After studying this chapter, you will be able to)

                1. อธิบายและแสดงตัวอย่างไฟล์ (File)

                2. แสดงลักษณะของ File Table

                3. แสดงโหมดในการเปิดใช้ File Table

                4. ยกตัวอย่างแสดงผลของการเปิดไฟล์

                5. ใช้โปรแกรมตรวจสอบการเปิดและปิดไฟล์

                6. แสดงโปรแกรมการอ่านข้อมูลจากไฟล์มาแสดง

                7. ยกตัวอย่างโปรแกรมคัดลอกข้อมูล

                8. แสดงโปรแกรมเขียนข้อมูลลงไฟล์

                9. ยกตัวอย่างโปรแกรมสร้าง Text File

              10. อธิบายและยกตัวอย่าง Binary File

              11. ยกตัวอย่างโปรแกรมเก็บข้อมูลนักศึกษา

              12. จัดบอร์ดเชิงปฏิบัติการ "ไฟล์" (File)

              13. สนทนาเชิงปฏิบัติการ "การอ่านข้อมูลจากไฟล์มาแสดง"

              14. อธิบายคำศัพท์ได้ 12 คำ



บทที่ 12

ไฟล์
    File   
ไฟล์ (File) คือ ที่เก็บข้อมูลต่าง ๆ ของคอมพิวเตอร์ ในภาษา C นั้น ไฟล์ก็จะมีความหมายรวมไปถึงอุปกรณ์ต่างที่ต่อกับเครื่องคอมพิวเตอร์ด้วย เช่น คีย์บอร์ด จอภาพ เป็นต้น
การติดต่อกับไฟล์จะต้องผ่านลิจิกคอลอินเตอร์เฟส (Logical Interfaces) ที่เรียกว่า สตีม (Stream) สตรีมจะช่วยให้ผู้ใช้เขียนโปรแกรมติดต่อกับอุปกรณ์ต่าง ๆ ได้ ซึ่งสตรีมที่ใช้ติดต่อกับไฟล์ ไฟล์จะมีอยู่ 2 ประเภท คือ
Text files เป็นไฟล์ของตัวอักษร เพราะมีโครงสร้างในการเก็บข้อมูลจะเป็นตัวอักษร ไฟล์นั้นจึงไม่สามารถที่จะเก็บข้อมูลที่ค่าตัวเลขจำนวนเต็ม จุดทศนิยม หรือในลักษณะที่เป็นโครงสร้าง ซึ่งการเก็บ ข้อมูลจะถูกแปลงเป็นเลขฐานสองตามรหัส ASCII
Binary Files เป็นไฟล์ที่เก็บข้อมูลที่อยู่ในรูปแบบของค่าต่าง ๆ ซึ่งข้อมูลที่ไฟล์ประเภทนี้จัดเก็บ จะสามารถเป็นได้ทั้งตัวเลขจำนวนเต็ม ตัวเลขทศนิยม ตัวอักษร อาร์เรย์ และข้อมูลแบบโครงสร้าง โดยการจัดเก็บนั้นจะเก็บลงไปตรง ๆ เลย เช่น 16706 ก็จะเก็บเป็นค่าที่เหมือนอ่านกลับมาเป็นค่าเดิม แต่ Text Files จะเก็บเป็นตัวอักษร 1 6 7 0 6
  Files Table
ก่อนที่ใช้ไฟล์ได้ ผู้ใช้จะต้องรู้จักกับ Files Table ซึ่ง Files Table คือ ส่วนของหน่วยความจำที่เก็บข้อมูลต่าง ๆ ที่เกี่ยวกับไฟล์ เช่น ชื่อไฟล์ เป็นตัวชี้ตำแหน่งของไฟล์ เป็นต้น โดยจะมีตัวแปรที่เป็นไฟล์พอยเตอร์ชี้อยู่ ซึ่งไฟล์พอยเตอร์ตัวนี้จะมีข้อมูลเป็นโครงสร้างชนิด FILE
ซึ่งการประกาศไฟล์พอยเตอร์มีรูปแบบดังนี้
FILE *[ชื่อไฟล์พอยเตอร์]
            ตัวอย่างเช่น
            FILE*fpTempData;
  Text File 
ฟังก์ชันที่เกี่ยวกับไฟล์นั้นจะใช้ไลบรารีไฟล์  stdio.h ซึ่งเป็นไลบรารีไฟล์มาตรฐานที่ต้องใช้อยู่เสมอ จึงไม่จำเป็นต้องนำเข้าไลบรารีไฟล์อื่น ๆ อีก
การเปิดไฟล์
ฟังก์ชันในการเปิดไฟล์ คือ ฟังก์ชัน fopen ฟังก์ชันนี้ต้องการพารามิเตอร์ 2 ตัว ตัวแรก คือ ชื่อไฟล์ที่ต้องการจะเปิด ซึ่งอาจจะรวมที่อยู่ของไฟล์ (Path) ในกรณีที่ไฟล์ที่ต้องการใช้ไม่ได้อยู่ที่เดียวกับไฟล์โปรแกรม และตัวที่ 2 จะเป็นโหมดในการเปิด ซึ่งจะมีโหมดการเปิดอยู่ 3 โหมดดังที่แสดงในตารางที่ 3-1
ตารางที่ 3-1 แสดงโหมดในการเปิดใช้ Text File

โหมด

ความหมาย

r

เปิดไฟล์ขึ้นมาเพื่ออ่าน

  1. ถ้าเปิดสำเร็จ ไฟล์พอยเตอร์จะชี้ไปที่ต้นไฟล์
  2. ถ้าเปิดไม่ได้ จะส่งค่ากลับเป็นค่า Error (Null)

w

เปิดไฟล์ขึ้นมาเพื่อเขียน

  1. ถ้าเปิดสำเร็จ จะได้ไฟล์ว่าง ๆ
  2. ถ้าเปิดไม่ได้ จะสร้างไฟล์ที่ต้องการให้ใหม่

a

เปิดไฟล์ขึ้นมาเพื่อเขียนต่อ

  1. ถ้าเปิดสำเร็จ ไฟล์พอยเตอร์จะชี้ไปที่ปลายไฟล์
  2. ถ้าเปิดไม่ได้ จะสร้างไฟล์ที่ต้องการให้ใหม่

            ชื่อไฟล์ คือ สตริงที่เป็นชื่อของไฟล์ ซึ่งอาจจะรวมกับที่อยู่ของไฟล์ (Path) ด้วย ซึ่งไฟล์ที่ใช้จะมีนามสกุล .dat
TEMPS.DAT

            ฟังก์ชันการเปิดไฟล์มีรูปแบบดังนี้
fopen (“[ชื่อไฟล์พอยเตอร์]”, “[โหมด]”);
ฟังก์ชัน fopen ถ้าเปิดไฟล์ได้สำเร็จจะส่งค่ากลับไปตำแหน่งที่อยู่ของไฟล์ ซึ่งจะต้องเก็บไว้ที่ไฟล์พอยเตอร์ที่ได้ประกาศไว้ก่อนหน้านี้แล้ว แต่ถ้าเปิดไม่สำเร็จจะส่งค่ากลับเป็นค่าวางหรือ Null รูปแบบการเปิดที่ถูกจะต้องเป็นดังรูปแบบด้านล่างนี้
มีรูปแบบดังนี้
                        [ชื่อไฟล์พอยเตอร์] = fopen (“[ชื่อไฟล์พอยเตอร์]”, “[โหมด]”;
ตัวอย่าง
            fpTempData = fopen(“TEMPS.DAT”, “W”);
            fpTempData = fopen(“A:\\TEMPS.DAT”, “W”);
การปิดไฟล์
            เมื่อเปิดใช้ไฟล์แล้วใช้เสร็จ ก็ควรจะทำการปิดไฟล์ที่ใช้ด้วย ซึ่งฟังก์ชันที่ใช่ปิดไฟล์ คือ ฟังก์ชัน fclose ซึ่งมีรูปแบบดังนี้
ฟังก์ชันการปิดไฟล์มีรูปแบบดังนี้
                        fclose ([ชื่อไฟล์พอยเตอร์]);
ตัวอย่าง
            fclose(fpTempData);
            ในการเปิดและปิดไฟล์นั้นอาจจะเกิดการผิดพลาดขึ้นได้ จนทำให้การเปิดและปิดไฟล์ไม่สมบูรณ์ ถ้าเปิดไฟล์ไม่สำเร็จ ฟังก์ชัน fopen จะส่งค่ากลับมาเป็นค่า Null และถ้าการปิดไฟล์ไม่สำเร็จจะส่งค่ากลับเป็น EOF ซึ่งจากตรงนี้ทำให้สามารถเขียนโปรแกรมเพื่อตรวจสอบการเปิดและปิดไฟล์ เพื่อป้องกันไม่ให้การทำงานของโปรแกรมผิดพลาด ดังแสดงในโปรแกรมที่ 12-1
โปรแกรมที่ 12-1 โปรแกรมตรวจสอบการเปิดและปิดไฟล์

#include<stdio.h>
…
int main(void)
{
/*การประกาศตัวแปรแบบ Local*/
FILE *fpTemps;
/*คำสั่ง*/
...
if((fpTemps = fopen(“TEMPA.DAT”, “r”)) = = NULL)
{
printf(“\nERROR opening TEMPS.DAT\n”);
return (100);
}/*if open*/
…
if(fclose(fpTemps) = = EOF)
{
printf(“\nERROR closing TEMPS.DAT\n”);
return (100);
}/*if close*/
…
}/*main*/

การอ่านและเขียนไฟล์
            ฟังก์ชันในอ่านและเขียนไฟล์นั้น คือ ฟังก์ชัน fscanf และ fprintf ตามลำดับ
fscanf เป็นฟังก์ชันในการอ่านข้อมูลจากไฟล์ ซึ่งการทำงานก็เหมือนกับฟังก์ชัน scanf แต่จะต่างกันตรงที่ฟังก์ชัน fscanf จะต้องใช้ไฟล์พอยเตอร์เพื่อชี้ตำแหน่งที่จะอ่านจากไฟล์มีรูปแบบดังนี้
fscanf ([ชื่อไฟล์พอยเตอร์], “[รูปแบบข้อความ]”, [ที่อยู่ของตัวแปร]);
ในการอ่านข้อมูลนั้น ผู้ใช้จะต้องรู้อยู่แล้วว่าข้อมูลที่จะไปอ่าน เก็บอยู่ในลักษณะอย่างไร แล้วจึงเขียนรูปแบบข้อความตามนั้น เช่น ข้อมูลที่เก็บเป็นดังด้านล่างนี้
5-10-1936
ชุดคำสั่งการอ่านจะเป็นดังนี้
            fscanf (fpData, “%d-%d-%d”, &month, &day, &year);
            fprintf เป็นฟังก์ชันในการเขียนข้อมูลลงไปในไฟล์ ซึ่งการทำงานก็เหมือนกับฟังก์ชัน printf แต่จะใช้ไฟล์พอยเตอร์เป็นตัวชี้ตำแหน่งของไฟล์ที่จะเขียนข้อมูลลงไป ซึ่งมีรูปแบบดังนี้
                        fprintf ([ชื่อไฟล์พอยเตอร์], “[รูปแบบข้อความ]”, [ตัวแปร]);
             ในการจะเขียนข้อมูลลงไปในไฟล์ไม่ต้องคำนึงถึงเรื่องใด ข้อมูลที่จะเขียนลงไปจะเป็นไปตามรูปแบบข้อความทั้งหมด ถ้าตรงไหนเป็นตัวกำหนดชนิดข้อมูล จะกลายเป็นค่าของตัวแปรตัวนั้นแทน เช่น
            fprintf(“fpOurt, “%d\n%d\n%d”,i,j,k);
            เมื่อคำสั่งนี้ทำงานค่าที่เก็บในไฟล์จะเป็นดังนี้
100
200
300
            ตัวอย่าง
            โปรแกรม 12-2 จะอ่านข้อมูลจากไฟล์ที่ชื่อ 12-2.DAT ซึ่งข้อมูลที่เก็บอยู่ข้างในเป็นดังนี้
            1 2 3 4 5 6 7 8 9 10

โปรแกรมที่ 12-2 โปรแกรมการอ่านข้อมูลจากไฟล์มาแสดง

 

 

#include<stdio.h>
#include<conio.h>
{
            /*การประกาศตัวแปรแบบ Local*/
           FILE *fpIn;
           int numIn;
           /*คำสั่ง*/
           fpIn = fopen(“12-02.DAT”, “r”);
           if(!fpIn)
           {
                       printf(“Coule not open file\a\n”);
                       exit(101);
            }/*if open fail*/
            while((fscanf(fpIn, “%d”,&numIn)) = = 1)
                        printf(“%d”, numIn);
             return 0;
}/*main*/
ผลลัพธ์ที่ได้ :
              1 2 3 4 5 6 7 8 9 10

 

 

โปรแกรมที่ 12-3 จะอ่านข้อมูลจากไฟล์ 12.2.DAT ไปเก็บไว้ที่ไฟล์ 12-3.DAT
โปรแกรมที่ 12-3 โปรแกรมคัดลอกข้อมูล

#include<stdio.h>
#include<conio.h>
{
            /*การประกาศตัวแปรแบบ Local*/
            FILE *fpIn;
            FILE *fpOut;
            int numIn;
            int closeRecult;
            /*คำสั่ง*/
            printf(“Running file copy\n”);
            fpIn = fopen(“12-02.DAT”, “r”);
            if(!fpIn)
            {
                      printf(“Could not open input file\a\n”);
                      exit(101);
             }/*if open fail*/
             fpOut = fopen(“12-03.DAT”, “w”);
             if(!fpOut)
            {
                      printf(“Could not open output file\a\n”);
                      exit(102);
             }/*if open fail*/
             while((fscanf(fpIn, “%d”,&numIn)) = = 1)
                      fprintf(fpOut, “%d\n”,numIn);
            closeResult = fclose(fpOut);
            if(closeResult = = EOF)
            {
                       printf(“Could not open output file\a\n”);
                       exit(201);
             }/*if close fail*/
             printf(“File copy complete \n”);
             return 0;          
}/*main*/

ผลลัพธ์ที่ได้  :
              Running file copy
              File copy complete

โปรแกรมที่ 12-4 เป็นโปรแกรมนำข้อมูลที่รับเข้ามา มาเขียนต่อในไฟล์เดิม
โปรแกรมที่12-4 โปรแกรมเขียนข้อมูลลงไฟล์


#include<stdio.h>
#include<conio.h>
int main(void)
{
         /*การประกาศตัวแปรแบบ Local*/
         FILE *fpAppnd;
         int numIn;
         int closeResult;
         /*คำสั่ง*/
         printf(“This program appends data to a file\n”);
         fpAppnd = fopen(“12-01.DAT”, “a”);
        if(!pIn)
       {
        printf(“Could not open input file\a\n”);
        exit(101);
        }/*if open fail*/
        printf(“Please enter first number : ”);
        while((scanf(“%d”, &numIn)) ! = EOF);
        {
                   fprintf(fpOut, “%d\n”, numIn);
                   printf(“Enter next number or <EOF> : ”);
         }
         closeResult = fclose(fpAppnd);
         if (closeResult = = EOF)
         {
                   printf(“Could not open output file\a\n”);
                   exit (201);
          }/*if close fail*/
          Printf(“File append complete \n”);
          Return 0;
}/*main*/

ผลลัพธ์ที่ได้  :
           This program appends data to a file
           Please enter first number : 1
           Enter next number or <EOF> : 2
           Enter next number or <EOF> : 3
           Enter next number on <EOF< : ^d
           File append complete

ฟังก์ชันการอ่านและเขียนข้อมูลที่เป็นตัวอักษร
getc และ fgetc ทั้งสองฟังก์ชันนี้จะมีการทำงาน คือ จะอ่านตัวอักษรต่อไปจากไฟล์ ขึ้นมาเลย และถ้าอ่านไปจนจบไฟล์ ทั้งสองก็จะส่งค่ากลับเป็น EOF ซึ่งตัวอย่างในการใช้ได้แสดงในหน้าถัดไป
nextChar = getc(fpMyFile);
            nextChar = fgetc(fpMyFile);
putc และ fputtc  ทั้งสองฟังก์ชันนี้จะมีการทำงาน คือ จะเขียนข้อมูลลงไปในไฟล์ทีละ 1 ตัวอักษร ถ้าการเขียนข้อมูลสมบูรณ์จะส่งค่ากลับมาเป็นต้นอักษรที่ส่งไป แต่ถ้าไม่สมบูรณ์จะส่งค่ากลับเป็น EOF ซึ่งตัวอย่างการใช้ทั้งสองฟังก์ชันดังแสดงในตัวอย่างด้านล่าง
            Putc (oneChar, fpMyFile);)
            Fputc(oneChar, fpMyFile);
ตัวอย่างโปรแกรม โปรแกรมที่   12 – 5  เป็นโปรแกรมที่จะรับตัวอักษรจากผู้ใช้  และสร้าง Text File เพื่อเก็บข้อมูลที่รับเข้ามา
โปรแกรมที่ 12-5 โปรแกรมสร้าง  Text File

#include<stdio.h>
int main (void)
{
                        /*การประกาศตัวแปรแบบ Local*/
                        FILE *fpText;
                        Char c;
                        int closeResult;
                        /*คำสั่ง*/
                        printf(“This program copies your input to a file\n”);
                        printf(“When you are through, enter <EOF>.\n\n”);
                         if (!(fpText = fopen(“12 – 05.DAT”,”w”)))
                         {
                                    printf(“Could not opening FILE1.DAT for writing”);
                                    Return (1);
                        } /*if open*/
                         while (( c = getche())!= EOF)
                                     fputc(c, fpText);
                          closeResult = fclose(fpText);
                          if (closeResult = = EOF)
                        {
                                    Printf(“Error closing file \a\n”);
                                    Return 201;
                        } /*if*/
                         Printf(“\n\n Your file is complete \n”);
                        Return 0;
}/*main*/

ผลลัพธ์ที่ได้
                                    This program copies your input to a file
                                    When you are through, enter <EOF>.

                                    Now is the time for all good students
                                    To come to the aid of their college.^d

                                    Your file is complete

           
           
  Binary  File
            Binary  File  เมื่อสังเกตดี ๆ จะมีเก็บข้อมูลเหมือนการเก็บข้อมูลเป็นเรคคอร์ด ซึ่งทำให้การ อ่าน – เขียนนั้นกระทำได้ค่อนข้างที่จะง่ายกว่า Text File
การเปิดไฟล์และปิดไฟล์
            ในการเปิดและปิด Binary File นั้นจะเหมือนกับ Text File เลย แต่สิ่งที่ต่างกันจะมีอยู่ตรงที่โหมดในการเปิดไฟล์ ซึ่งโหมดในการเปิด Binary File แสดงในตารางที่ 3 – 2
ตารางที่ 3 – 2 แสดงโหมดในการเปิดใช้ Binary  File

โหมด

ความหมาย

rb

เปิดไฟล์ขึ้นมาเพื่ออ่าน

  1. ถ้าเปิดสำเร็จ ไฟล์พอยเตอร์จะชี้ไปที่ต้นไฟล์
  2. ถ้าเปิดไม่ได้ จะส่งค่ากลับเป็นค่า Error (Null)

wb

เปิดไฟล์ขึ้นมาเพื่อเขียน

  1. ถ้าเปิดสำเร็จ จะได้ไฟล์ว่าง ๆ
  2. ถ้าเปิดไม่ได้ จะสร้างไฟล์ที่ต้องการให้ใหม่

ab

เปิดไฟล์ขึ้นมาเพื่อเขียนต่อ

  1. ถ้าเปิดสำเร็จ ไฟล์พอยเตอร์จะชี้ไปที่ปลายไฟล์
  2. ถ้าเปิดไม่ได้ จะสร้างไฟล์ที่ต้องการให้ใหม่

การอ่านและเขียนไฟล์
            ฟังก์ชันในการอ่านและเขียนไฟล์นั้น คือ ฟังก์ชัน fread และ fwrite ตามลำดับ
Fread  เป็นฟังก์ชันในการอ่านข้อมูลจากไฟล์  ซึ่งมีรูปแบบดังนี้
Fread ([ชื่อตัวแปร],[ขนาดของตัวแปร],[จำนวน],[ชื่อไฟล์พอยเตอร์]);
ในการอ่านข้อมูลจาก Binary File จะต้องกำหนดขนาดของข้อมูลและจำนวนที่อ่านขึ้นมาเพราะอย่างที่ได้กล่าวไปในข้างต้นแล้ว Binary File จะเก็บข้อมูลในลักษณะรูปแบบทางคอมพิวเตอร์ เช่น ผู้ใช้ต้องการอ่านข้อมูลที่ตัวเลขจำนวนเต็ม 1 ตัว ซึ่งตัวเลขจำนวนเต็มจะใช้พื้นที่ในการเก็บข้อมูล  2  ไบต์  เพราะฉะนั้นขนาดที่จะกำหนดจะต้องเป็น  2  เพื่อให้การอ่านข้อมูลนั้น อ่านขึ้นมาแล้วสามารถเก็บลงในตัวแปรได้ถูกต้อง ตัวอย่างด้านล่างเป็นตัวอย่างการใช้ฟังก์ชัน fread
Fead (num,sizeof(int),1,fpData);
            จากคำสั่งด้านบนสามารถเขียนโปรแกรมให้อ่านข้อมูลไปเรื่อยจนกว่าจะจบไฟล์ได้ ซึ่งแสดงในโปรแกรมที่ 12-6
โปรแกรมที่ 12-6 โปรแกรมการอ่านข้อมูลจากไฟล์


#include<stdio.h>
int mani (void)
{
/*การประกาศตัวแปรแบบ Local*/
FILE *fpData;
int num;
int itemsRead;
/*คำสั่ง*/
fpData = fopen (“int_file.DAT”, “rb”);
…
while((itemsRead = Fread (num,sizeof(int),1,fpData))!=0)
printf(“%d”,num);
…
}/*main*/

            จากกฎเกณฑ์ในหน้าที่ผ่านมา  ทำให้สามารถที่จะอ่านข้อมูลที่มีการเก็บในลักษณะที่เป็นโครงสร้างได้ ซึ่งการอ่านในลักษณะที่เป็นแบบเรคคอร์ด  ดังแสดงในรูป

           

 

 

int readStudent (STR*oneStudent,FILE*strFile)
            {
            /การประกาศตัวแปรแบบ Local*/
            Int ioResults;
            /*คำสั่ง*/
            ioResults = fread (oneStudent,sizeot (STU), 1,stuFile);
            return ioResults;
            }/* redStudent*/

 

Fwrite  เป็นฟังก์ชันในการเขียนข้อมูลลงในไฟล์ ซึ่งมีรูปแบบดังนี้
Fwrite ([ชื่อตัวแปร],[ขนาดของตัวแปร],[จำนวน],[ชื่อไฟล์พอยเตอร์]);
ฟังก์ชันนี้จะคล้ายกับฟังก์ชัน fread  แต่ทำเป็นการเขียนแทน  โดยสิ่งที่ต้องการก็เหมือนกัน ดังแสดงในตัวอ่ย่างด้านล่างนี้
Fwrite  (num,sizeof(int),1,fpData);

 

 

โปรแกรมที่ 12 – 8 โปรแกรมการเขียนข้อมูลแบบโครงสร้าง

Void writStudent (STU * aStudent,FILE*strFile)
{
            /*การประกาศตัวแปรแบบ Local*/
            Int ioResults;
            /*คำสั่ง*/
            ioResults = fwrite (aStudent,sizeof(STU),1,stuFile);
            if(ioResult ! = 1)
            {
                        Printf(“\aError writing student file\a\n”);
                        Exit(100);
            }
            Return;
}/*writStudent*/

 

 

ฟังก์ชันบอกสถานะของไฟล์
            Feof  เป็นฟังก์ชันที่จะบอกว่าขณะนี้  ไฟล์พอยเตอร์ไปอยู่ที่ตำแหน่งสิ้นสุดไฟล์หรือยัง ซึ่งจะส่งค่ากลับมาเป็น 0 เมื่อสิ้นสุดไฟล์แล้ว และจะส่ง กลับมาเป็น  ไม่เท่ากับ 0  เมื่อยังไม่สิ้นสุดไฟล์  การใช้แสดงดังตัวอย่างด้านล่าง
            Sts = feof(fpData);
            Forror  ฟังก์ชันนี้จะคอยตรวจสอบข้อผิดพลาดต่าง ๆ ที่เกิดขึ้นขณะที่อ่านหรือเขียนข้อมูล ซึ่งถ้าเกิดข้อผิดพลาดจะส่งค่ากลับมาเป็น  ไม่เท่ากับ 0 แต่ถ้าไม่มีข้อผิดพลาดจะส่งค่ากลับมาเป็น 0
            Sts = ferror(fpData);
ฟังก์ชันตำแหน่งของไฟล์พอยเตอร์
                Rewind  จะเป็นฟังก์ชันในการย้ายตำแหน่งของไฟล์พอยเตอร์  ให้ไปอยู่ที่หัวไฟล์  ซึ่งการใช้คำสั่งนี้แสดงอยู่ในตัวอย่างด้านล่าง
                Rewind(fpData);
                Ftell  เป็นฟังก์ชันที่จะส่งค่ากลับ  เป็นตำแหน่งที่อยู่ของไฟล์พอยเตอร็ในขณะนั้น  ซึ่งค่าที่ส่งกลับมาเป็นข้อมูลชนิด  long  int  การใช้คำสั่งนี้แส่ดงดังอยู่ในตัวอย่างด้านล่าง
                Posfp = ftell(fpData);
ฟังก์ชันของระบบ
                Remove  เป็นฟังกฟ์ชันที่ใช้ลบไฟล์ที่ต้องการทิ้งไป ถ้าการลบสมบูรณ์จะส่งค่ากลับมาเป็น 0 และถ้าไม่สมบูรณ์จะส่งค่ากลับเป็น  ไม่เท่ากับ 0  ซึ่งตังอย่างการใช้ฟังก์ชันเป็นดังนี้
                If(remove(“file1.dat”))
                                Printf(“Error,file cannot be deleted”);
                Rename  เป็นฟังก์ชันที่จะใช้เปลี่ยนชื่อไฟล์ที่ต้องการ  ถ้าการเปลี่ยนสมบูรณ์จะส่งค่ากลับมาเป็น 0 และถ้าไม่สมบูรณ์จะส่งค่ากลับเป็น  ไม่เท่ากับ 0 ซึ่งตัวอย่างการใช้ฟังก์ชันเป็นดังนี้
                If(rename (“file1.at”,”file1.bak))
                                Printf(“Error, the file cannot be rename”);
                ตัวอย่างโปรแกรม  โปรแกรมที่ 12 – 9 เป็นโปรแกรมที่ใช้เก็บข้อมูลนักเรียน  ซึ่งจะเก็บชื่อ รหัส และคะแนนการทดสอบต่าง ๆ

                #include<stdio.h>
                /* การประกาศตัวแปรแบบ Global*/
                Typedef struct stuData
             {
              Char name[26];
                                Char id[5];
                                Int  exams[3];
                                Int problems[8];
                                Char grade;
                /*การประกาศตัวแปรแบบฟังก์ชัน*/
                Char * getData (FILE *texFile,STU_DATA*aStudent);
                Void  writeBinaryFile(STU_DATA *asStudent,FILE*binFile);
                Int main(void)
                {
              /*การประกาศตัวแปรแบบ Local*/
                                Char * textFileID = “students.txt:”;
                                Char *binFileID = “Students.bin”;
                                STU_DATA aStudent;
                                FILE *textFile;
                                FILE *binFile;
                                /*คำสั่ง*/
                                Printf(“\nBegin  Student Binary File Creation\n”);
                                If(!(textFile = fopen (textFileID,”r”)))
                                {
                                                Printf(“Cannot open %s\n”,textFileID);
                                Exit(100);
                                }/*if textFile*/
                                If(!(binFile =  fopen (BinFileID,”wb”)))
                                {
                                                Printf(“Cannot open%s\n”,binFileID);
                                                Exit(200);
                                }/*if binFile*/
                                While (getData(textFile,^astudent)))
WiriteBinaryFile(&aStudent,binFile);
                                Fclose(textfile);
                                Fclose(binFile);
                                Printf(“\n\nFile creation complete\n”);
                                Return 0;
                }/*main*/
                Char *getData(FILE *getData(FILE *textFile,Stu_DATA*aStu)
                {
                                /*การประกาศตัวแปรแบบ  Local*/
                                Char *ioResult;
                                Char buffer[100]”;
                                /*คำสั่ง*/
                                ioResult = fgets(buffer,sizeof(buufer),textFile);
                                if (ioResult)
                                fscanf(buffer,”%s%s%d%d%d%d%d%d%d%d%d%d%c”,
aStu->name,aStu->id,
&aStu->exams[0],&aStu->exams[1],
&aStu->exams[2],&aStu->exams[3],
&aStu->exams[4],&aStu->exams[5],
&aStu->exams[06],&aStu->exams[7],
&aStu->grade);
Return ioResult);
}/*getData*/

                            Void WriteBinaryFile(STU_DATA*asStudent,Fil\LE*binFile)
                            {
                             /*คำสั่ง*/
                            amtWritten = fwrite(aStudent,aizeof(STU_DATA),1,binFile);
if(amtWritten !=1)

                            { 
                            Printf(“Can,t write student file. Exiting\n”);
Exit(201);

                }/*if*/
Return;
}/* writeBinaryFile*/

               
                               
                               
                                               

บทที่ 12