บทที่9

แฟ้มข้อมูลในภาษาC

สำหรับบทนี้เป็นบทสุดท้ายของเอกสารเล่มนี้ โดยจะกล่าวถึงแฟ้มข้อมูลในภาษา C ซึ่งจะทำให้ผู้เขียนโปรแกรมมีความรู้ความสามารถเกี่ยวกับการจัด การสร้าง และการเรียกใช้แฟ้มข้อมูลในภาษา C ตามความต้องการของผู้ใช้งาน ซึ่งได้แบ่งหัวข้อต่าง ๆ เกี่ยวกับแฟ้มข้อมูลในภาษา C ดังรายละเอียดดังต่อไปนี้

9.1 ความหมายของแฟ้มข้อมูลในภาษา C
แฟ้มข้อมูล (data file) คือ แฟ้มที่มีการเก็บข้อมูลที่มีความสัมพันธ์กันมาไว้ด้วยกัน โดยมีการเก็บข้อมูลอย่างต่อเนื่องกันไป ตั้งแต่ต้นแฟ้มข้อมูลไปจนกระทั่งจบแฟ้มข้อมูล โดยที่ผู้เขียนข้อมูลสามารถแบ่งข้อมูลที่ต้องการจัดเก็บลงในแฟ้มเป็น field หรือ record ก็ได้ หรืออาจจัดเก็บข้อมูลตามแนวขนาดเนื้อที่โดยไม่จำเป็นต้องแบ่งข้อมูลในแฟ้ม เป็น field หรือ record ก็ได้ โดยปกติผู้เขียนโปรแกรมภาษา C นิยมแบ่งข้อมูลที่ต้องการลงในแฟ้มเป็น field หรือ record เพราะมีความสะดวกในการเรียกใช้ข้อมูลจากแฟ้มที่ต้องการนอกจากนี้ยังสามาถใช้ โปรแกรม text editor หรือโปรแกรม word processing สร้างแฟ้มข้อมูลที่ต้องการได้อย่างสะดวกรวดเร็ว

9.2 ลักษณะโครงสร้างของแฟ้มข้อมูลทั่วไป

ลักษณะโครงสร้างของแฟ้มข้อมูลทั่วไปสามารถแสดงให้เห็นได้ดังรูปต่อไปนี้
รูปที่ 9.1 แสดงลักษณะของแฟ้มข้อมูลทั่วไป

จากรูป 9.1 ลักษณะโครงสร้างของแฟ้มข้อมูลจะเห็นได้ว่าแฟ้มข้อมูล 1 แฟ้ม ประกอบด้วยข้อมูลเรคอร์ดที่ 1 ถึงเรคอร์ดที่ n โดยที่แต่ละเรคอร์ดประกอบด้วย ฟิลด์ 1 ถึง ฟิลด์ที่ m

เพื่อความเข้าใจเกี่ยวกับลักษณะโครงสร้างของแฟ้มข้อมูลมากยิ่งขึ้น ให้ศึกษาตารางที่ 9.1 ต่อไปนี้

9.2 ลักษณะโครงสร้างของแฟ้มข้อมูลทั่วไป

ลักษณะโครงสร้างของแฟ้มข้อมูลทั่วไปสามารถแสดงให้เห็นได้ดังรูปโครงสร้างต่อไปนี้

รูปที่ 9.1 แสดงลักษณะของแฟ้มข้อมูลทั่วไป

จากรูป 9.1 ลักษณะโครงสร้างของแฟ้มข้อมูลจะเห็นได้ว่าแฟ้มข้อมูล 1 แฟ้ม ประกอบด้วยข้อมูลเรคอร์ดที่ 1 ถึงเรคอร์ดที่ n โดยที่แต่ละเรคอร์ดประกอบด้วย ฟิลด์ 1 ถึง ฟิลด์ที่ m

เพื่อความเข้าใจเกี่ยวกับลักษณะโครงสร้างของแฟ้มข้อมูลมากยิ่งขึ้น ให้ศึกษาตารางที่ 9.1 ต่อไปนี้

ตารางที่ 9.1 แสดงแฟ้มข้อมูลนักศึกษาจำนวน 10 คน

ลำดับที่

รหัสประจำตัวนักศึกษา

ชื่อ-นามสกุลนักศึกษา

1

441725101

นางสาวจรรยา พลหาญ

2

441725102

นายยอด ราชชิต

3

441725103

นางสาววนิดา อุดานนท์

4

441725104

นางสาวกมลนิตย์ ทองมหา

5

441725105

นางสาวเจนจิราพร คิอินธิ

6

441725106

นางสาวนภา พุทธสาวงษ์

7

441725107

นายนิพน ราชาไช

8

441725108

นางสาวจันดา แสนต่างใจ

9

441725109

นายสมศักดิ์ งอยแพง

10

441725110

นายทัศน์ชัย อภัยโส

ตารางข้างต้น จะเห็นว่าข้อมูลนักศึกษามี 10 record (ข้อมูล 1 คน = 1 record) โดยที่ในแต่ละ record ประกอบไปด้วยฟิลด์ 2 ฟิลด์ คือ ฟิลด์ที่ 1 คือ รหัสประจำตัวนักศึกษา และฟิลด์ที่ 2 คือ ชื่อ – นามสกุลนักศึกษา

ข้อควรจำ ในวิชาฐานข้อมูลและระบบการจัดการฐานข้อมูล จะใช้คำว่า “ table “ แทนแฟ้มข้อมูล

9.3 การประมวลผลแฟ้มข้อมูลในภาษา C (data file processing in C)

โดยปกติแล้วผู้เขียนโปรแกรมเกี่ยวกับแฟ้มข้อมูลในภาษา C จะมีความต้องประมวลผลแฟ้มข้อมูลอยู่ 3 แบบ คือ

1) การบันทึกข้อมูลในแฟ้มข้อมูล (write data into file)
2) การอ่านข้อมูลขึ้นจากแฟ้มข้อมูลขึ้นมาใช้งาน (read data from file)
3) การเพิ่มข้อมูลลงไปในแฟ้มข้อมูล (append data into file)

9.3.1 การบันทึกข้อมูลเก็บไว้ในแฟ้มข้อมูล (write data into file) มีขั้นตอนดังนี้
1. เปิดแฟ้มข้อมูลด้วยคำสั่ง fopen( ) ตั้งชื่อแฟ้มข้อมูล (file name) พร้อมกับระบุ mode ของการบันทึกข้อมูลลงในแฟ้มเป็น “w”
2. บันทึกข้อมูลลงในแฟ้มโดยใช้ฟังก์ชัน putc( ) หรือ fprintf( ) หรือ fwrite( ) บันทึกข้อมูลลงแฟ้ม ขึ้นอยู่กับลักษณะของข้อมูลที่ต้องการบันทึกลงแฟ้มดังนี้

  • ถ้าข้อมูลที่ต้องการบันทึกเป็นตัวอักขระตัวเดียว (single character) ให้ฟังก์ชัน putc( ) เพราะสามารถบันทึกตัวอักขระตัวเดียวได้ดี
  • ถ้าข้อมูลที่ต้องการบันทึกเป็นตัวเลขจำนวนเต็ม (integer) หรือตัวเลขจำนวนทศนิยม (floationg point) หรือสตริง (strings) ให้ใช้ฟังก์ชัน fprintf( ) เพราะสามารถจัดรูปแบบข้อมูลที่บันทึกได้
  • ถ้าข้อมูลที่ต้องการบันทึกเป็นข้อมูลแบบโครงสร้าง (structures) หรือตัวแปรชุด (arrays) ให้ใช้ฟังก์ชัน fwrite( ) เพราะสามารถกำหนดเนื้อที่และจำนวนครั้งของการบันทึกข้อมูลได้

3. หลังจากบันทึกข้อมูลลงแฟ้มเรียบร้อยแล้ว จะต้องใช้คำสั่ง fclose( ) ปิดแฟ้มข้อมูลทุกครั้งเพื่อป้องกันความเสียหายที่อาจเกิดขึ้นได้

ข้อมูลควรระวังเกี่ยวกับการบันทึกข้อมูลลงแฟ้ม

ในฟังก์ชัน fopen( ) เมื่อใช้ mode “w” เป็นการเปิดแฟ้มข้อมูลเพื่อบันทึกข้อมูลลงในแฟ้มเท่านั้น ถ้าเป็นแฟ้มข้อมูลเก่าที่เคยเก็บข้อมูลไว้แล้ว จะมีผลทำให้ข้อมูลทั้งหมดในแฟ้มข้อมูลเก่า ถูกลบทิ้งไปโดยอัตโนมัติ แล้วสร้างแฟ้มข้อมูลใหม่ขึ้นมาแทนที่

9.3.2 การอ่านข้อมูลขึ้นจากแฟ้มข้อมูล (read data from file) มีขั้นตอนดังนี้

1. เปิดแฟ้มข้อมูลด้วยคำสั่ง fopen( ) ตั้งชื่อแฟ้มข้อมูล พร้อมกับระบุ mode ของการบันทึกข้อมูลลงแฟ้มเป็น “r”
2. อ่านข้อมูลขึ้นจากแฟ้มโดยสามารถใช้ฟังก์ชัน getc( ) หรือ fscanf( ) หรือ fread( ) อ่านข้อมูลขึ้นจากแฟ้มได้ ขึ้นอยู่กับลักษณะของข้อมูลที่ต้องการอ่านขึ้นจากแฟ้มดังนี้

  • ถ้าข้อมูลที่ต้องการอ่านขึ้นจากแฟ้มเป็นตัวอักขระตัวเดียวให้ใช้ฟังก์ชัน getc( ) เพราะสามารถอ่านข้อมูลตัวอักขระตัวเดียวได้ดี
  • ถ้าข้อมูลที่ต้องการอ่านขึ้นจากแฟ้มเป็นตัวเลขจำนวนเต็ม หรือตัวเลขจำนวนทศนิยม หรือสตริงให้ใช้ฟังก์ชัน fscanf( ) เพราะสามารถจัดรูปแบบข้อมูลที่อ่านขึ้นจากแฟ้มได้
  • ถ้าข้อมูลที่ต้องการอ่านจากแฟ้ม เป็นข้อมูลแบบโครงสร้าง หรือตัวแปรชุดให้ใช้ฟังก์ชัน fread( ) เพราะสามารถกำหนดขนาดเนื้อที่และจำนวนครั้งของการอ่านข้อมูลขึ้นจากแฟ้มได้

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

ข้อควรระวังเกี่ยวกับการอ่านข้อมูลขึ้นจากแฟ้ม

ในฟังก์ชัน fopen( ) เมื่อใช้ mode “r” เป็นการเปิดแฟ้มข้อมูล เพื่ออ่านข้อมูลขึ้นจากแฟ้มข้อมูลอย่างเดียว ไม่สามารถบันทึกข้อมูลเพิ่มเติมลงไปในแฟ้มได้

9.3.3 การเพิ่มข้อมูลลงไปในแฟ้มข้อมูล (append data into file)
มีขั้นตอนดังนี้
1. เปิดแฟ้มข้อมูล ด้วยคำสั่ง fopen( ) ตั้งชื่อแฟ้มข้อมูลพร้อมกับระบุ mode ของการอ่านข้อมูลจากแฟ้มเป็น “a”
2. เขียนคำสั่งเกี่ยวกับการบันทึกข้อมูลเพิ่มลงแฟ้ม โดยสามารถใช้คำสั่ง fprintf( ) บันทึกข้อมูลลงแฟ้มหรือจะใช้คำสั่ง fwrite( ) บันทึกข้อมูลลงแฟ้มก็ได้ ขึ้นอยู่กับความต้องการของผู้เขียนโปรแกรม
3. หลังจากบันทึกข้อมูลลงแฟ้มเสร็จเรียบร้อยแล้ว จะต้องใช้คำสั่ง fclose( ) ปิดแฟ้มข้อมูลทุกครั้งเพื่อป้องกันความเสียหายที่อาจเกิดขึ้นได้

ข้อควรระวังเกี่ยวกับการเพิ่มข้อมูลลงแฟ้ม

ในฟังก์ชัน fopen( ) เมื่อใช้ mode “a” เป็นการเปิดแฟ้มข้อมูลสำหรับบันทึกข้อมูลเพิ่มเติมลงไปในแฟ้มได้ โดยที่ข้อมูลที่เพิ่มเข้าไปจะเป็นข้อมูลชุดสุดท้ายของแฟ้มเสมอ

9.4 ฟังก์ชันที่ใช้ในการเปิดและปิดแฟ้มข้อมูล
การเปิดแฟ้มข้อมูลในภาษา C สามารถทำได้โดยใช้ฟังก์ชัน fopen( ) ส่วนการปิดแฟ้มข้อมูลสามารถทำได้โดยใช้ฟังก์ชัน fclose( ) ซึ่งมีรายละเอียดการใช้งานแต่ละฟังก์ชัน ดังนี้

9.4.1 ฟังก์ชัน fopen( )
ฟังก์ชัน fopen( ) เป็นฟังก์ชันที่ใช้ในการเปิดแฟ้มข้อมูลที่ต้องการได้ โดยที่ fopen เป็นฟังก์ชันมาตรฐานที่อยู่ในแฟ้ม stdio.h
ดังนั้นก่อนที่จะใช้ฟังก์ชันนี้ จะต้องใช้คำสั่ง #include<stdio.h> อยู่ที่ส่วนต้นของโปรแกรมภาษา C และจะต้องประกาศแฟ้มข้อมูลด้วย คำสั่ง FILE ดังนี้

รูปแบบการประกาศแฟ้มข้อมูลและเปิดแฟ้มข้อมูล

FILE *fp;
fp = fopen(filename,mode);

โดยที่

fp คือ ตัวชี้ตำแหน่งข้อมูลในแฟ้ม (file pointer) เมื่อใช้คำสั่ง FILE *fp; มีผลทำให้ตัว file pointer ชี้ไปที่ตำแหน่งเริ่มต้นของแฟ้มข้อมูลทันที โดยที่ fp นี้จะสามารถชี้ไปยังข้อมูลที่ต้องการในแฟ้มได้โดยอัตโนมัติ เมื่อมีการบันทึกข้อมูล หรือการอ่านข้อมูลจากแฟ้ม
filename คือ ชื่อแฟ้มข้อมูลที่ตั้งขึ้น โดยต้องเขียนอยู่ภายใต้เครื่องหมาย “…”
mode คือลักษณะของการใช้แฟ้มข้อมูล เช่น เปิดแฟ้มขึ้นมาเพื่อบันทึกข้อมูลหรืออ่านข้อมูลขึ้นมาใช้งาน หรือเพิ่มข้อมูลเข้าไปในแฟ้ม เป็นต้น โดยที่ mode ของการใช้งานแฟ้มข้อมูลมีอยู่หลายชนิดดังตารางที่ 9.2 ต่อไปนี้

ตารางที่ 9.2 แสดง mode ของการใช้แฟ้มข้อมูลในฟังก์ชัน fopen( )

Mode

ความหมาย

text file

binary file

”r”,”rt”

“rb”

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

“w”,”wt”

“wb”

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

“a”,”at”

“ab”

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

“r+t”

“r+b”

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

“w+t”

“w+b”

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

“a+t”

“a+b”

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

ตัวอย่างที่ 9.1 แสดงการประกาศแฟ้มข้อมูลและเปิดแฟ้มข้อมูล

FILE *fp;
fp = fopen(“A:test.dat”,”w”);

หมายความว่า เปิดแฟ้มข้อมูลชื่อว่า test.dat อยู่ที่ drive A เพื่อใช้สำหรับบันทึกข้อมูลลงแฟ้ม (write) อย่างเดียว โดยมีตัวแปร fp เป็น file pointer ชี้ตำแหน่งของข้อมูลใน file

ข้อควรจำ ฟังก์ชัน fopen( ) จะให้ค่า file pointer (fp) เท่ากับ NULL เมื่อเกิดข้อผิดพลาดในการเปิดไฟล์ หรือไม่สามารถเปิดไฟล์ที่ระบุไว้ได้ ในกรณีที่สามารถเปิดแฟ้มข้อมูลได้สำเร็จจะให้ค่า file pointer (fp) ไม่เท่ากับ NULL

ตัวอย่างที่ 9.2 แสดงการประกาศแฟ้มข้อมูลและเปิดแฟ้มข้อมูลพร้อมกับตรวจสอบการเปิดแฟ้ม

FILE *fp;
If((fp=fopen(“A:test.dat”,”w”))==NULL)
{
printf(“Error in open file”);
exit(1);
}

จากตัวอย่างคำสั่งข้างต้น เราสามารถนำไปใช้งานในโปรแกรมเพื่อตรวจสอบการเปิดแฟ้มข้อมูลได้สำเร็จหรือ ไม่ ถ้าเปิดแฟ้มไม่สำเร็จจะพิมพ์ข้อความว่า “Error in open file” ออกทางจอภาพแล้วออกจากโปรแกรมด้วยคำสั่ง exit(1); ในทางตรงกันข้ามถ้าเปิดแฟ้มข้อมูลได้สำเร็จ จะไม่มีข้อความดังกล่าวข้างต้นและโปรแกรมยังสามารถทำงานต่อไปได้

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

รูปแบบการปิดแฟ้มข้อมูล

fclose(file pointer);

ตัวอย่างที่ 9.3 แสดงการปิดแฟ้มข้อมูล

fclose(fptr); โดยที่ fptr เป็น file pointer ของแฟ้มข้อมูลที่ต้องการปิด

ข้อควรจำ ฟังก์ชัน fclose( ) จะให้ค่าเท่ากับศูนย์ (NULL) เมื่อปิดไฟล์ได้สำเร็จ

9.5 การใช้ฟังก์ชัน putc( ) และ getc( )
9.5.1 ฟังก์ชัน putc( )

เป็นฟังชันที่ใช้บันทึกข้อมูลตัวอักขระตัวเดียวลงไปในแฟ้มข้อมูลที่ต้องการ
รูปแบบการใช้ฟังก์ชัน

putc(single_char,fp);

โดยที่

single_char คือ ค่าคงที่ชนิดตัวอักขระตัวเดียว หรือตัวแปรชนิดsingle_character
fp คือ file pointer ของแฟ้มข้อมูลที่ต้องการบันทึกข้อมูลลงไป

เพื่อความเข้าใจเกี่ยวกับการใช้งานฟังก์ชัน putc( ) จึงควรศึกษาโปรแกรมตัวอย่างดังนี้

โปรแกรมตัวอย่างที่ 9.1 แสดงการใช้ฟังก์ชัน putc( ) บันทึกข้อมูลตัวอักขระลงแฟ้มข้อมูล

/* file1.c */

#include<stdio.h> /* บรรทัดที่ 1 */
#include<conio.h> /* บรรทัดที่ 2 */
#include<stdlib.h> /* บรรทัดที่ 3 */
void main(void) /* บรรทัดที่ 4 */
{ /* บรรทัดที่ 5 */
FILE *fp; /* บรรทัดที่ 6 */
char ch; /* บรรทัดที่ 7 */
clrscr(); /* บรรทัดที่ 8 */
if(( fp=fopen(“a:testdata.dat”,”w”))==NULL) /* บรรทัดที่ 9 */
{ /* บรรทัดที่ 10 */
printf(“Error in open file”); /* บรรทัดที่ 11 */
printf(“07”); /* บรรทัดที่ 12 */
exit(1); /* บรรทัดที่ 13 */
} /* บรรทัดที่ 14 */
printf(“Please press <Enter> to quit program.\n”); /* บรรทัดที่ 15 */
printf(“\nEnter your sentence : “); /* บรรทัดที่ 16 */
do /* บรรทัดที่ 17 */
{ /* บรรทัดที่ 18 */
ch=getche( ); /* บรรทัดที่ 19 */
putc(ch, fp); /* บรรทัดที่ 20 */
} while(ch !=’\r’); /* \r = Enter */ /* บรรทัดที่ 21 */
fclose(fp); /* บรรทัดที่ 22 */
} /* บรรทัดที่ 23 */

หมายเหตุ ก่อน run โปรแกรมต้องใส่แผ่นดิสก์เก็ตต์ไว้ในไดร์ฟ a: เพื่อเก็บแฟ้มข้อมูล testdata.dat ที่สร้างจากโปรแกรมนี้

ผลลัพธ์ที่ได้จากโปรแกรม

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

คำอธิบายโปรแกรม
จากโปรแกรมตัวอย่างที่ 9.1 สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ ได้ดังนี้

บรรทัดที่ 1 คำสั่ง #include <stdio.h> สำหรับโปรแกรมนี้ ฟังก์ชันที่เพิ่มขึ้นมาจากโปรแกรมก่อน ๆ ที่เราพบ ที่ต้องใช้ควบคู่กับไฟล์ stdio.h คือ ฟังก์ชัน fopen( ) ในบรรทัดที่ 9
บรรทัดที่ 3 คำสั่ง #include <stdlib.h> จะสนับสนุนการทำงานของฟังก์ชัน exit( ) ในบรรทัดที่ 13
บรรทัดที่ 6 คำสั่ง FILE *fp; รูปแบบการประกาศแฟ้มข้อมูล โดยที่ fp คือตัวชี้ตำแหน่งข้อมูลในแฟ้ม (file pointer) เมื่อใช้คำสั่ง FILE *fp; มีผลทำให้ตัว file pointer ชี้ไปที่ตำแหน่งเริ่มต้นของแฟ้มข้อมูลทันที (ในโปรแกรมนี้จะให้แฟ้มข้อมูลอยู่ที่ไดร์ฟ a: ชื่อ testdata.dat โดยที่ fp นี้จะสามารถชี้ไปยังข้อมูลหรือการค้นข้อมูลจากแฟ้ม
บรรทัดที่ 9 คำสั่งนี้จะสัมพันธ์ และต่อเนื่องกับคำสั่งบรรทัดที่ 6 นั่นคือต้องการเปิดแฟ้มข้อมูลที่ไดร์ฟ a: ชื่อ testdata.dat เพื่อใช้สำหรับบันทึกข้อมูลลงแฟ้ม (write) อย่างเดียว และคำสั่งบรรทัดที่ 9 จะตรวจสอบด้วยว่า fp เท่ากับศูนย์ (NULL) หรือไม่ ถ้า fp เท่ากับศูนย์ แสดงว่าเกิดข้อผิดพลาดในการเปิดไฟล์ หรือไม่สามารถเปิดไฟล์ที่ระบุไว้ได้ ก็จะไปทำคำสั่งใน บรรทัดที่ 10 ถึง 14 นั่นคือ พิมพ์ Error in open file ที่จอภาพ และมีเสียง bell ดังเตือน กรณีที่จะเกิดข้อผิดพลาดได้ เช่น ไม่ได้ใส่แผ่นที่ไดร์ฟ a แต่ถ้าเปิดแฟ้มข้อมูลได้ก็จะให้ค่า fp ที่ไม่เท่ากับศูนย์ และไปทำคำสั่งตั้งแต่บรรทัดที่ 15 จนจบโปรแกรม
บรรทัดที่ 15 และ 16 พิมพ์ข้อความบอกให้ทราบว่า ถ้าต้องการออกจากโปรแกรมให้กด Enter แต่ถ้าจะทำงานต่อให้เติมประโยค และไปทำงานต่อในคำสั่งถัดไป
บรรทัดที่ 17 ถึง 21 คำสั่ง do จะวนรับตัวอักขระที่ผู้ใช้เติมเก็บไว้ที่ตัวแปร ch แล้วนำไปเขียนลงแฟ้มข้อมูล และสุดท้าย ตรวจสอบเงื่อนไขด้วยว่า ผู้ใช้เติม enter หรือไม่ จะได้ออกจากการทำงาน แต่ถ้าไม่ใช่ก็จะวนรับตัวอักขระไปเรื่อย ๆ
บรรทัดที่ 22 คำสั่ง fclose (fp); ปิดแฟ้มข้อมูล

9.5.2 ฟังก์ชัน getc( )
เป็นฟังก์ชันที่ใช้อ่านข้อมูลตัวอักขระตัวเดียวขึ้นจากแฟ้มข้อมูลที่ต้องการ

รูปแบบการใช้ฟังก์ชัน

getc(fp);
หรือ
single_char = getc(fp);

โดยที่
single_char คือ ตัวแปรชนิด single character ที่ใช้เก็บข้อมูลตัวอักขระ ตัวเดียว
fp คือ file pointer ของแฟ้มข้อมูลที่ต้องการบันทึกข้อมูลลงไป

เพื่อความเข้าใจเกี่ยวกับการใช้งานฟังก์ชัน getc( ) จึงควรศึกษาโปรแกรมตัวอย่างดังนี้

โปรแกรมตัวอย่างที่ 9.2 แสดงการใช้ฟังก์ชัน getc( ) อ่านข้อมูลตัวอักขระขึ้นจากแฟ้มข้อมูล

/* file2.c */

#include<stdio.h> /* บรรทัดที่ 1 */
#include<conio.h> /* บรรทัดที่ 2 */
#include<stdlib.h> /* บรรทัดที่ 3 */
void main(void) /* บรรทัดที่ 4 */
{ /* บรรทัดที่ 5 */
FILE *fp; /* บรรทัดที่ 6 */
char ch; clrscr(); /* บรรทัดที่ 7 */
clrscr(); /* บรรทัดที่ 8 */
if(( fp=fopen(“a:testdata.dat”,”r”))==NULL) /* บรรทัดที่ 9 */
{ /* บรรทัดที่ 10 */
printf(“Error in open file”); /* บรรทัดที่ 11 */
printf(“07”); /* บรรทัดที่ 12 */
exit(1); /* บรรทัดที่ 13 */
} /* บรรทัดที่ 14 */
do /* บรรทัดที่ 15 */
{ /* บรรทัดที่ 16 */
ch=getc(fp); /* บรรทัดที่ 17 */
putchar(ch); /* บรรทัดที่ 18 */
} while(ch !=EOF); /* บรรทัดที่ 19 */
fclose(fp); /* บรรทัดที่ 20 */
getch(); /* บรรทัดที่ 21 */
} /* บรรทัดที่ 22 */

หมายเหตุ ก่อน run โปรแกรมต้องใส่แผ่นดิสก์เก็ตต์ไว้ในไดร์ฟ a: ที่มีแฟ้ม testdata.dat ที่เคยสร้างไว้แล้ว เพื่อให้โปรแกรมอ่านข้อมูลจากแฟ้มนี้

ผลลัพธ์ที่ได้จากโปรแกรม

ข้อสังเกต ข้อมูลที่อ่านได้จากโปรแกรมตัวอย่างที่ 9.2 เป็นข้อมูลที่เราเขียนใส่ไว้ในแฟ้มข้อมูลจากโปรแกรมตัวอย่างที่ 9.1

คำอธิบายโปรแกรม
จากโปรแกรมตัวอย่างที่ 9.2 สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ ได้ดังนี้
การทำงานของโปรแกรมตัวอย่างที่ 9.2 จะคล้ายกับโปรแกรมตัวอย่างที่ 9.1 คือมีการเปิดแฟ้มข้อมูลขึ้นมา ชื่อ testdata.dat ที่ไดร์ฟ a: แต่เปิดขึ้นมาเพื่ออ่านข้อมูลในแฟ้ม ซึ่งมีการตรวจสอบการเปิดแฟ้มข้อมูลก่อนว่าผิดพลาดหรือไม่ ถ้าผิดพลาดจะพิมพ์ข้อความบอก และมีเสียง bell ดังขึ้น แต่ถ้าเปิดได้ก็จะเข้าไปอ่านข้อมูลในแฟ้มข้อมูลออกมาแสดงเรื่อย ๆ จนกว่าจะจบแฟ้ม ซึ่งคำสั่งบรรทัดที่ 19 (ch != EOF); จะเป็นการตรวจสอบว่าแฟ้มข้อมูลสิ้นสุดหรือไม่ (EOF คือ End Of File)

9.6 การใช้ฟังก์ชัน fprintf( ) และ fscanf( )

9.6.1 ฟังก์ชัน fprintf( )
เป็นฟังก์ชันที่ใช้บันทึกข้อมูล (write) ลงแฟ้มโดยสามารถจัดรูปแบบข้อมูลที่ต้องการบันทึกได้คล้ายกับฟังก์ชัน printf( ) แตกต่างกันตรงที่ printf( ) เป็นฟังก์ชันที่ใช้พิมพ์ผลลัพธ์ออกทางจอภาพแต่ฟังก์ชัน fprintf( ) ใช้บันทึกข้อมูลลงแฟ้ม
รูปแบบการใช้

fprintf (fp,control string,variable list);

fp คือ ตัวชี้ตำแหน่งในแฟ้มข้อมูล
control string คือ รหัสรูปแบบข้อมูลและรหัสควบคุมใช้เหมือนฟังก์ชัน printf( ) เช่น สามารถระบุชนิดของข้อมูลที่ต้องการบันทึกลงแฟ้มเป็น %d, %c, %f, %s หรือใช้รหัสควบคุม \n หรือ \t ก็ได้
variable list คือ ค่าคงที่ ตัวแปร หรือนิพจน์ที่จะเขียนลงแฟ้มข้อมูล ถ้าเป็นค่าคงที่สตริงต้องเขียนอยู่ภายในเครื่องหมาย “…”

ตัวอย่างที่ 9.4 แสดงการใช้ฟังก์ชัน fprintf( )

int x=15; float f=4.562; char str[20]=”Computer”;
FILE *fptr;
fprintf(fptr, “%d \t %f \t %s \n”,x,f,str);

fptr คือ ตัวชี้ตำแหน่งในแฟ้มข้อมูล (file pointer)
x คือ ตัวแปร int เก็บข้อมูลตัวเลข 15 ซึ่งจะถูกบันทึกลงแฟ้มเป็น field ที่ 1
f คือ ตัวแปร float เก็บข้อมูลตัวเลข 4.562 ซึ่งจะถูกบันทึกลงแฟ้มเป็น field ที่ 2
str คือ ตัวแปร string เก็บข้อความว่า “Computer” ซึ่งจะถูกบันทึกลงแฟ้มเป็น field ที่ 3
\t คือ รหัสควบคุมที่สั่งให้ tab ไป 1 ครั้ง ก่อนที่จะบันทึกข้อมูล field ต่อไป
\n คือ รหัส new line ใช้สั่งให้ขึ้นบรรทัดใหม่ในแฟ้มข้อมูล

9.6.2 ฟังก์ชัน fscanf( )
เป็นฟังก์ชันที่ใช้อ่านข้อมูล (read) ขึ้นจากแฟ้มข้อมูลแล้วนำมาเก็บไว้ในตัวแปรที่ต้องการได้โดยมีการทำงานคล้าย กับฟังก์ชัน scanf( ) แตกต่างกันตรงที่ฟังก์ชัน fscanf( ) เป็นฟังก์ชันที่ใช้อ่านข้อมูลจากแฟ้มข้อมูลแต่ฟังก์ชัน scanf( ) เป็นฟังก์ชันที่ใช้รับข้อมูลจากคีย์บอร์ดแล้วไปเก็บไว้ในตัวแปรที่ต้องการ

รูปแบบการใช้

fscanf( fp, control string, variable list);

โดยที่

fp คือ ตัวชี้ตำแหน่งในแฟ้มข้อมูล
control string คือ รหัสรูปแบบข้อมูลใช้เหมือนฟังก์ชัน scanf( ) เช่น สามารถระบุชนิดของข้อมูลที่ต้องการอ่านข้อมูลจากแฟ้มเป็น %d,%c,%f,%s และยังสามารถใช้รหัส new line
หรือ \n ได้
variable list คือ ชื่อตัวแปรที่ใช้เก็บข้อมูลที่อ่านมาจากแฟ้มข้อมูล โดยจะต้องระบุเครื่องหมาย & (ampersand) นำหน้าชื่อตัวแปรด้วย ยกเว้นตัวแปรสตริงเท่านั้นที่ไม่ต้องมีเครื่องหมาย &

ตัวอย่างที่ 9.5 แสดงการใช้ฟังก์ชัน fscanf( )

int i; float f; char str[80];
FILE *fptr;
fscanf( fptr,”%d %f %s \n”,&i,&f,str);

โดยที่

i คือ ตัวแปรชนิด int ใช้เก็บข้อมูลที่อ่านจากแฟ้ม field ที่ 1
f คือ ตัวแปรชนิด float ใช้เก็บข้อมูลที่อ่านจากแฟ้ม field ที่ 2
str คือ ตัวแปรสตริง ใช้เก็บข้อมูลที่อ่านจากแฟ้ม field ที่ 3
fptr คือ file pointer ใช้ชี้ตำแหน่งข้อมูลในแฟ้ม

เพื่อความเข้าใจเกี่ยวกับการใช้ฟังก์ชัน fprintf( ) และฟังก์ชัน fscanf( ) มากยิ่งขึ้น ให้ศึกษาจากโปรแกรมตัวอย่างดังต่อไปนี้

โปรแกรมตัวอย่างที่ 9.3 แสดงการใช้ฟังก์ชัน fprintf( ) บนทึกข้อมูลลงในแฟ้ม 1 record

/* wdataf.c */
/* this program for write one record into data file */

#include<stdio.h> /* บรรทัดที่ 1 */
#include<stdlib.h> /* บรรทัดที่ 2 */
#include<conio.h> /* บรรทัดที่ 3 */
void main(void) /* บรรทัดที่ 4 */
{ /* บรรทัดที่ 5 */
FILE *fptr; /* บรรทัดที่ 6 */
int x=5; float f=4.5; char str[80]=”C and C++ Programming”; /* บรรทัดที่ 7 */
char fname[80]; /* บรรทัดที่ 8 */
clrscr( ); /* บรรทัดที่ 9 */
printf(“Enter your file name ( file format is *.dat ) :”); /* บรรทัดที่ 10 */
gets(fname); /* บรรทัดที่ 11 */
if( (fptr=fopen(fname, “w”)) == NULL ) /* บรรทัดที่ 12 */
{ /* บรรทัดที่ 13 */
printf(“Error in open file “); /* บรรทัดที่ 14 */
printf(“07”); /* บรรทัดที่ 15 */
exit(1); /* บรรทัดที่ 16 */
} /* บรรทัดที่ 17 */
fprintf(fptr, “%d \t %.2f \t %s\n”, x, f, str); /* บรรทัดที่ 18 */
fclose(fptr); /* บรรทัดที่ 19 */
} /* บรรทัดที่ 20 */

หมายเหตุ ถ้าต้องการเก็บแฟ้มข้อมูลไว้ในไดร์ฟ a: ก่อน run โปรแกรมต้องใส่แผ่นดิสก์เก็ตต์ไว้ในไดร์ฟ a: เพื่อเก็บแฟ้มข้อมูลที่สร้างจากโปรแกรมนี้

ผลลัพธ์ที่ได้จากโปรแกรม

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

คำอธิบายโปรแกรม
จากโปรแกรมตัวอย่างที่ 9.3 สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ ได้ดังนี้

การทำงานของโปรแกรมตัวอย่างนี้ จะให้เปิดแฟ้มข้อมูลขึ้นมาเพื่อเขียน โดยให้ผู้ใช้งานตั้งชื่อแฟ้มเอง แต่ให้มีนามสกุล .dat เช่น a:test1.dat คือ ตั้งชื่อแฟ้ม test.dat เก็บไว้ที่ไดร์ฟ a ถ้าเปิดไม่ได้ก็จะพิมพ์ข้อผิดพลาด และมีเสียง bell ดัง บอกให้ทราบ ซึ่งถ้าเปิดได้แล้วจะนำค่าของตัวแปร x, f และ ตัวแปร str เขียนลงในแฟ้มข้อมูลดังกล่าว 1 record ตามคำสั่งอยู่ที่บรรทัดที่ 18 ซึ่งการเขียนข้อมูลจะมีการเว้นช่องว่างในแต่ละฟิลด์ เนื่องจากมีการใช้รหัส \t และ \n ทำให้เกิดความสะดวกในการอ่านข้อมูลจากแฟ้มขึ้นมาใช้งานต่อไป เขียนเสร็จแล้วก็จะใช้ฟังก์ชัน fclose( ) เพื่อปิดแฟ้มข้อมูล ในบรรทัดที่ 19

โปรแกรมตัวอย่างที่ 9.4 แสดงการใช้ฟังก์ชัน fprintf( ) บันทึกข้อมูลลงในแฟ้มควบคู่กับคำสั่ง for

/* wdataf2.c */
/* this program for write 5 record into data file */

#include<stdio.h> /* บรรทัดที่ 1 */
#include<stdlib.h> /* บรรทัดที่ 2 */
#include<conio.h> /* บรรทัดที่ 3 */
void main(void) /* บรรทัดที่ 4 */
{ /* บรรทัดที่ 5 */
FILE *fptr; /* บรรทัดที่ 6 */
int x=1; float f=8.5; char str[80]=”C and C++ Programming”; /* บรรทัดที่ 7 */
int j; /* บรรทัดที่ 8 */
char fname[80]; /* บรรทัดที่ 9 */
clrscr( ); /* บรรทัดที่ 10 */
printf(“Enter your file name ( file format is *.dat ) :”); /* บรรทัดที่ 11 */
gets(fname); /* บรรทัดที่ 12 */
if( (fptr=fopen(fname, “w”)) == NULL ) /* บรรทัดที่ 13 */
{ /* บรรทัดที่ 14 */
printf(“Error in open file “); /* บรรทัดที่ 15 */
printf(“07”); /* บรรทัดที่ 16 */
exit(1); /* บรรทัดที่ 17 */
} /* บรรทัดที่ 18 */
for(j=1; j<=5; j++)
{ /* บรรทัดที่ 19 */
fprintf(fptr, “%d \t %.2f \t %s\n “, x, f, str); /* บรรทัดที่ 20 */
x= x+1; /* บรรทัดที่ 21 */
f= f+1.5; /* บรรทัดที่ 22 */
} /* บรรทัดที่ 23 */
fclose(fptr); /* บรรทัดที่ 24 */
} /* บรรทัดที่ 25 */

หมายเหตุ ถ้าต้องการเก็บแฟ้มข้อมูลไว้ในไดร์ฟ a: ก่อน run โปรแกรมต้องใส่แผ่นดิสก์เก็ตต์ไว้ในไดร์ฟ a: เพื่อเก็บแฟ้มข้อมูลที่สร้างจากโปรแกรมนี้

ผลลัพธ์ที่ได้จากโปรแกรม

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

คำอธิบายโปรแกรม
จากโปรแกรมตัวอย่างที่ 9.4 สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ ได้ดังนี้

โปรแกรมตัวอย่างที่ 9.4 จะทำงานคล้ายกับโปรแกรมตัวอย่างที่ 9.3 คือเปิดแฟ้มข้อมูลขึ้นมาเพื่อเขียน เช่น เขียนที่ไดร์ฟ a:test2.dat แต่จะเขียนข้อมูลมากกว่า 1 record โดยใช้คำสั่ง for ช่วย ซึ่งคำสั่งอยู่บรรทัดที่ 19 ถึง 23 คือเขียนค่าตัวแปร x, f และ str ลงในแฟ้ม และแต่ละ record ที่เขียนจะมีการคำนวณเปลี่ยนค่าตัวแปร x และ f ด้วย เมื่อเขียนเสร็จแล้วก็จะปิดแฟ้มข้อมูล ด้วยฟังก์ชัน fclose( ) ในคำสั่งบรรทัดที่ 24

โปรแกรมตัวอย่างที่ 9.5 แสดงการใช้ฟังก์ชัน fscanf( ) อ่านข้อมูลจากแฟ้ม 1 record

หมายเหตุ ก่อน run โปรแกรมต้องใส่แผ่นดิสก์เก็ตต์ไว้ในไดร์ฟ a: ที่มีแฟ้ม test1.dat ที่เคยสร้างไว้แล้ว เพื่อให้โปรแกรมอ่านข้อมูลจากแฟ้มนี้

ผลลัพธ์ที่ได้จากโปรแกรม

ข้อสังเกต ข้อมูลที่อ่านได้จากโปรแกรมตัวอย่างที่ 9.5 เป็นข้อมูลที่เราเขียนใส่ไว้ในแฟ้มข้อมูลจากโปรแกรมตัวอย่างที่ 9.3

คำอธิบายโปรแกรม
จากโปรแกรมตัวอย่างที่ 9.5 สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ ได้ดังนี้

โปรแกรมตัวอย่างนี้ จะเปิดแฟ้มข้อมูลขึ้นมาเพื่ออ่านข้อมูล โดยให้ผู้ใช้วนเติมชื่อแฟ้มข้อมูลที่ต้องการอ่าน เช่น เราจะอ่านแฟ้มที่บันทึกข้อมูลได้จากโปรแกรมตัวอย่างที่ 9.3 คือ a:test1.dat ซึ่งคำสั่งบรรทัดที่ 18 อ่านข้อมูลขึ้นมาเก็บไว้ที่ตัวแปร x, f, c,str1, str2 และตัวแปร str3 แล้วทำงานคำสั่งบรรทัดที่ 19 คือนำค่าที่เก็บไว้ในตัวแปรดังกล่าวแสดงออกที่จอภาพ หลังจากทำงานเสร็จสิ้นแล้ว จะปิดแฟ้มข้อมูลด้วยฟังก์ชัน fclose( ) ในคำสั่งบรรทัดที่ 20

โปรแกรมตัวอย่างที่ 9.6 แสดงการใช้ฟังก์ชัน fscanf( ) อ่านข้อมูลจากแฟ้ม ควบคู่กับคำสั่ง for

/* rdataf2.c */
/* this program for read 5 record from data file */
/* and print data to monitor */

#include<stdio.h> /* บรรทัดที่ 1 */
#include<stdlib.h> /* บรรทัดที่ 2 */
#include<conio.h> /* บรรทัดที่ 3 */
void main(void) /* บรรทัดที่ 4 */
{ /* บรรทัดที่ 5 */
FILE *fptr; /* บรรทัดที่ 6 */
int x; float f; char c, str1[80],str2[80],str3[80]; /* บรรทัดที่ 7 */
int j; /* บรรทัดที่ 8 */
char fname[80]; /* บรรทัดที่ 9 */
clrscr( ); /* บรรทัดที่ 10 */
printf(“Enter your file name ( file format is *.dat ) :”); /* บรรทัดที่ 11 */
gets(fname); /* บรรทัดที่ 12 */
if( (fptr=fopen(fname, “r”)) == NULL ) /* บรรทัดที่ 13 */
{ /* บรรทัดที่ 14 */
printf(“Error in open file “); /* บรรทัดที่ 15 */
printf(“07”); /* บรรทัดที่ 16 */
exit(1); /* บรรทัดที่ 17 */
} /* บรรทัดที่ 18 */
for(j=1; j<=5; j++)
{ /* บรรทัดที่ 19 */
fscanf(fptr, “%d %f %c %s %s %s \n”, &x, &f,&c,str1,str2,str3); /* บ. 20 */
printf(“%d \t %.2f \t %c %s %s %s \n”,x,f,c,str1,str2,str3); /* บรรทัดที่ 21 */
} /* บรรทัดที่ 22 */
fclose(fptr); /* บรรทัดที่ 23 */
getch(); /* บรรทัดที่ 24 */
} /* บรรทัดที่ 25 */

หมายเหตุ ก่อน run โปรแกรมต้องใส่แผ่นดิสก์เก็ตต์ไว้ในไดร์ฟ a: ที่มีแฟ้ม test2.dat ที่เคยสร้างไว้แล้ว เพื่อให้โปรแกรมอ่านข้อมูลจากแฟ้มนี้

ผลลัพธ์ที่ได้จากโปรแกรม

ข้อสังเกต ข้อมูลที่อ่านได้จากโปรแกรมตัวอย่างที่ 9.6 เป็นข้อมูลที่เราเขียนใส่ไว้ในแฟ้มข้อมูลจากโปรแกรมตัวอย่างที่ 9.4

คำอธิบายโปรแกรม
จากโปรแกรมตัวอย่างที่ 9.6 สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ ได้ดังนี้

โปรแกรมตัวอย่างนี้จะทำงานคล้ายกับโปรแกรมตัวอย่างที่ 9.5 จะเปิดแฟ้มข้อมูลขึ้นมาอ่านข้อมูล โดยให้ผู้ใช้งานเติมชื่อแฟ้มข้อมูลที่ต้องการอ่าน เช่น เราจะค้นแฟ้มที่บันทึกข้อมูลได้จากโปรแกรมที่ 9.4 คือ a:test2.dat ซึ่งข้อมูลมีอยู่ทั้งหมด 5 record โดยใช้คำสั่ง for ช่วย ซึ่งคำสั่งอยู่บรรทัดที่ 19 ถึง 22 โดยที่คำสั่งบรรทัดที่ 20 จะอ่านข้อมูลขึ้นมาเก็บไว้ที่ตัวแปร x, f, c, str1, str2 และตัวแปร str3 แล้วนำค่าที่เก็บไว้ในตัวแปรดังกล่าวแสดงออกที่จอภาพ ตามลำดับ หลังจากทำงานเสร็จสิ้นแล้วจะปิดแฟ้มข้อมูลด้วยฟังก์ชัน fclose( ) ในคำสั่งบรรทัดที่ 23

9.7 การใช้ฟังก์ชัน fwrite( ) และ fread( )
การใช้ฟังก์ชัน fwrite( ) และ fread( ) ใช้ได้กับ binary file เท่านั้น
9.7.1 ฟังก์ชัน fwrite( )
ฟังก์ชัน fwrite( ) เป็นฟังก์ชันที่ใช้เก็บข้อมูล ลงแฟ้มโดยที่การเก็บข้อมูลแต่ละครั้ง สามารถกำหนดขนาดของข้อมูลที่ต้องการบันทึกได้
รูปแบบการใช้

fwrite(&var, size, n, fp);

โดยที่

&var คือ ตำแหน่งของตัวแปรที่เก็บข้อมูลที่ต้องการนำไปเก็บไว้ในแฟ้ม
size คือ ขนาดของข้อมูลที่ต้องการ write ลงแฟ้มในแต่ละครั้ง ซึ่งสามารถหาได้จากฟังก์ชัน sizeof(data type); หรือ sizeof(variable name); เช่น sizeof(int); หรือ sizeof(j);
n คือ จำนวนครั้งที่ต้องการ write ข้อมูลลงแฟ้ม
fp คือ ตัวชี้ตำแหน่งข้อมูลในแฟ้ม (file pointer)

ข้อควรจำ ฟังก์ชัน fwrite( ) จะให้ค่าเลขจำนวนเต็มเท่ากับ n (จำนวนครั้งที่ write ข้อมูลลงแฟ้ม) เมื่อไม่เกิดข้อผิดพลาดในการเขียนข้อมูล และจะให้ค่าน้อยกว่า n เมื่อมีข้อผิดพลาดเกิดขึ้น

ตัวอย่างที่ 9.6 แสดการใช้ฟังก์ชัน fwrite( )

เช่น 1)

FILE *fptr;
double x=1.2345678912345;
fwrite(&x,sizeof(double x),1,fptr);
เป็นการบันทึกข้อมูลที่เก็บไว้ในตัวแปร x ลงแฟ้มข้อมูล โดยทำการบันทึก 1 ครั้ง (n=1) ขนาดของข้อมูลที่บันทึกลงแฟ้มในแต่ละครั้งมีขนาด 8 bytes ตามชนิดตัวแปร x

2)

FILE *fptr; int j;
int a[10]={10,20,30,40,50,60,70,80,90,100};
for (j=0;j<10;j++)
fwrite(&a[j],sizeof(int a[j]),1,fptr);

เป็นการบันทึกข้อมูลที่เก็บไว้ในตัวแปรชุด a ลงแฟ้มข้อมูล โดยใช้คำสั่ง for มาช่วยทำการบันทึกข้อมูลลงแฟ้ม 10 ครั้ง โดยที่ขนาดของข้อมูลที่บันทึกลงแฟ้มในแต่ละครั้งมีขนาด 2 bytes ตามชนิดของตัวแปร a[j]
เพื่อความเข้าใจเกี่ยวกับการใช้ฟังก์ชัน fwrite( ) มากขึ้น ให้ศึกษาโปรแกรมตัวอย่างดังต่อไปนี้

โปรแกรมตัวอย่างที่ 9.7 แสดงการใช้งานฟังก์ชัน fwrite( ) เก็บข้อมูลลงแฟ้ม และสามารถกำหนดขนาดของข้อมูลที่ต้องการบันทึกได้

/* wdataf3.c */
/* this program for write student’s record into data file */
#include<stdio.h> /* บรรทัดที่ 1 */
#include<stdlib.h> /* บรรทัดที่ 2 */
#include<conio.h> /* บรรทัดที่ 3 */
#include<ctype.h> /* บรรทัดที่ 4 */
void main(void) /* บรรทัดที่ 5 */
{ /* บรรทัดที่ 6 */
struct
{ /* บรรทัดที่ 7 */
char name[30]; /* บรรทัดที่ 8 */
char id[20]; /* บรรทัดที่ 9 */
float gpa; /* บรรทัดที่ 10 */
}student; /* บรรทัดที่ 11 */
char numstr[80], fname[80]; /* บรรทัดที่ 12 */
FILE *fptr; /* บรรทัดที่ 13 */
printf(“Enter your file name (file format is *.dat) :”); /* บรรทัดที่ 14 */
gets(fname); /* บรรทัดที่ 15 */
if( (fptr=fopen(fname, “wb”)) == NULL )
{ /* บรรทัดที่ 16 */
printf(“Error in open file”); /* บรรทัดที่ 17 */
exit(1); /* บรรทัดที่ 18 */
} /* บรรทัดที่ 19 */
do
{ /* บรรทัดที่ 20 */
clrscr( ); /* บรรทัดที่ 21 */
printf(“\nEnter student name :”); /* บรรทัดที่ 22 */
gets( student.name ); /* บรรทัดที่ 23 */
printf(“Enter student id :”); /* บรรทัดที่ 24 */
gets( student.id ); /* บรรทัดที่ 25 */
printf(“Enter student gpa :”); /* บรรทัดที่ 26 */
gets( numstr ); /* บรรทัดที่ 27 */
student.gpa = atof(numstr); /* บรรทัดที่ 28 */
fwrite(&student, sizeof(student), 1, fptr); /* บรรทัดที่ 29 */
printf(“Add another student(y/n)?:”); /* บรรทัดที่ 30 */
} while( tolower(getche()) == ‘y’ ); /* บรรทัดที่ 31 */
fclose(fptr); /* บรรทัดที่ 32 */
getch(); /* บรรทัดที่ 33 */
} /* บรรทัดที่ 34 */

หมายเหตุ ถ้าต้องการเก็บแฟ้มข้อมูลไว้ในไดร์ฟ a: ก่อน run โปรแกรมต้องใส่แผ่นดิสก์เก็ตต์ไว้ในไดร์ฟ a: เพื่อเก็บแฟ้มข้อมูลที่สร้างจากโปรแกรมนี้

ผลลัพธ์ที่ได้จากโปรแกรม

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

คำอธิบายโปรแกรม

จากโปรแกรมตัวอย่างที่ 9.7 จะให้ผู้ใช้เติมข้อมูลเพื่อเก็บข้อมูลลงในแฟ้มข้อมูล ซึ่งสามารถเติมข้อมูลได้มากกว่า 1 record โดยผู้ใช้เป็นคนกำหนดเอง โดยโปรแกรมจะถามผู้ใช้ว่าจะเติมข้อมูลต่อไปอีกหรือไม่ภายหลังจากเติมข้อมูล แต่ละ record แล้ว ซึ่งถ้าตอบว่าใช่ ก็จะวนให้เติมข้อมูลอีก แต่ถ้าตอบว่าไม่ ก็จะจบการทำงาน โดยฟังก์ชันที่ใช้เก็บข้อมูลลงแฟ้ม คือ fwrite( ) ในคำสั่งบรรทัดที่ 29 และการเก็บข้อมูลจะเก็บไว้ที่ตัวแปร struct ซึ่งได้ประกาศไว้ในบรรทัดที่ 6

9.7.2 ฟังก์ชัน fread( )
ฟังก์ชัน fread( ) เป็นฟังก์ชันที่ใช้อ่านข้อมูลจากแฟ้ม โดยที่แต่ละครั้งสามารถกำหนดขนาด (size) ของข้อมูลที่ต้องการอ่านได้

รูปแบบการใช

fread(&var,size,n,fp);

โดยที่

&var คือ ตำแหน่งของตัวแปรที่เก็บข้อมูลที่ต้องการนำไปเก็บไว้ในแฟ้ม
size คือ ขนาดของข้อมูลที่ต้องการ read ขึ้นจากแฟ้มในแต่ละครั้ง ซึ่งสามารถหาได้จากฟังก์ชัน sizeof(data type); หรือ sizeof(variable name); เช่น sizeof(int); หรือ sizeof(j);
n คือ จำนวนครั้งที่ต้องการ read ข้อจากแฟ้ม
fp คือ ตัวชี้ตำแหน่งข้อมูลในแฟ้ม (file pointer)

ข้อควรจำ ฟังก์ชัน fread( ) จะให้ค่าตัวเลขจำนวนเต็ม = n เมื่อไม่เกิดข้อผิดพลาดในการอ่านข้อมูล และจะให้ค่าเป็นศูนย์ (0 หรือ NULL) เมื่อมีข้อผิดพลาดในการอ่านข้อมูลจากแฟ้มหรือสิ้นสุดไฟล์ (EOF)

ตัวอย่างที่ 9.7 แสดงการใช้ฟังก์ชัน fread( )

เช่น 1)

FILE *fptr;
double x;
fread(&x,sizeof(double x),1,fptr);
เป็นการอ่านข้อมูลในแฟ้มข้อมูลมาเก็บไว้ที่ตัวแปร x โดยทำการอ่านข้อมูล 1 ครั้ง (n=1) ขนาดของข้อมูลที่อ่านจากแฟ้มในแต่ละครั้งมีขนาด 8 bytes ตามชนิดตัวแปร x

2)

FILE *fptr;
int a[10]; int j;
for (j=0;j<10;j++)
fread(&a[ j],sizeof(int a[ j]),1,fptr);

เป็นการอ่านข้อมูลในแฟ้มมาเก็บไว้ในตัวแปรชุด a โดยทำการอ่านข้อมูล 10 ครั้ง โดยที่ขนาดของข้อมูลที่อ่านจากแฟ้มในแต่ละครั้งมีขนาด 2 bytes ตามชนิดตัวแปร a[j]
เพื่อความเข้าใจเกี่ยวกับการใช้ฟังก์ชัน fread( ) มากขึ้น ให้ศึกษาโปรแกรม ตัวอย่างดังต่อไปนี้

โปรแกรมตัวอย่างที่ 9.8 แสดงการใช้งานฟังก์ชัน fread( ) อ่านข้อมูลจากแฟ้มโดยแต่ละครั้งสามารถกำหนดขนาดข้อมูลที่ต้องการอ่านได้

/* rdataf3.c */
/* this program for read student’s record from data file */

#include<stdio.h> /* บรรทัดที่ 1 */
#include<conio.h> /* บรรทัดที่ 2 */
#include<stdlib.h> /* บรรทัดที่ 3 */
void main(void) /* บรรทัดที่ 4 */
{ /* บรรทัดที่ 5 */
struct
{ /* บรรทัดที่ 6 */
char name[30]; /* บรรทัดที่ 7 */
char id[20]; /* บรรทัดที่ 8 */
float gpa; /* บรรทัดที่ 9 */
} student; /* บรรทัดที่ 10 */
char fname[80]; /* บรรทัดที่ 11 */
FILE *fptr; clrscr(); /* บรรทัดที่ 12 */
printf(“Enter your file name (file format is *.dat) :”); /* บรรทัดที่ 13 */
gets(fname); /* บรรทัดที่ 14 */
if( (fptr=fopen(fname, “rb”)) == NULL )
{ /* บรรทัดที่ 15 */
printf(“Error in open file”); /* บรรทัดที่ 16 */
exit(1); /* บรรทัดที่ 17 */
} /* บรรทัดที่ 18 */
while( fread(&student, sizeof(student),1, fptr) == 1 ) /* บรรทัดที่ 19 */
{ /* บรรทัดที่ 20 */
printf(“\nName = %s\n”, student.name); /* บรรทัดที่ 21 */
printf(“Id = %s\n”, student.id); /* บรรทัดที่ 22 */
printf(“GPA = %.2f\n”, student.gpa); /* บรรทัดที่ 23 */
} /* บรรทัดที่ 24 */
fclose(fptr); /* บรรทัดที่ 25 */
getch(); /* บรรทัดที่ 26 */
}/* end main */ /* บรรทัดที่ 27 */

หมายเหตุ ก่อน run โปรแกรมต้องใส่แผ่นดิสก์เก็ตต์ไว้ในไดร์ฟ a: ที่มีแฟ้ม student.dat ที่เคยสร้างไว้แล้ว เพื่อให้โปรแกรมอ่านข้อมูลจากแฟ้มนี้

ผลลัพธ์ที่ได้จากโปรแกรม

คำอธิบายโปรแกรม
จากโปรแกรมตัวอย่างที่ 9.8 โปรแกรมจะอ่านข้อมูลในแฟ้มที่เราบันทึกไว้ในโปรแกรมตัวอย่างที่ 9.7 ที่ drive a: ชื่อ student.dat แล้วนำข้อมูลทั้งหมดแสดงออกที่จอภาพ

9.8 ฟังก์ชันที่ใช้ควบคุมตำแหน่งของ file pointer ในแฟ้มข้อมูล

การควบคุมตำแหน่งของ fp (file pointer) ในแฟ้มข้อมูล นิยมใช้กันมากในการประมวลผลแฟ้มข้อมูลแบบสุ่ม (random file access) ซึ่งสามารถให้ fp ไปยังตำแหน่งเริ่มต้นของแฟ้มข้อมูล (BOF =beginning of file) หรือ ตำแหน่งใดตำแหน่งหนึ่งในแฟ้มข้อมูลได้

ฟังก์ชันที่ใช้ควบคุมตำแหน่ง file pointer มีดังนี้

9.8.1 ฟังก์ชัน rewind( )
เป็นฟังก์ชันที่ใช้ย้ายตำแหน่งของ file pointer ไปยังตำแหน่งเริ่มต้นของแฟ้ม

รูปแบบการใช้

rewind(fp);

9.8.2 ฟังก์ชัน fseek( )
เป็นฟังก์ชันที่ใช้ย้ายตำแหน่งของ file pointer ไปยังตำแหน่งที่ต้องการในแฟ้มข้อมูลโดยจะต้องกำหนดจุดเริ่มต้น (origin) ของ file pointer และค่า offset

รูปแบบการใช้

fseek(fp, offset, origin);

โดยที่

offset คือ ระยะห่างจากตำแหน่งจุดเริ่มต้น มีหน่วยเป็น byte
origin คือ จุดที่ file pointer ชี้อยู่ มีอยู่ 3 สถานะ ดังนี้คือ

macro-name ค่าคงที่ ความหมาย
SEEK_SET 0 file pointer อยู่ที่ต้นแฟ้ม BOF
SEEK_CUR 1 file pointer อยู่ที่ตำแหน่งปัจจุบัน
SEEK_END 2 file pointer อยู่ที่ท้ายไฟล์ EOF

ตัวอย่างที่ 9.8 แสดการใช้งาน fseek(fptr,10,0);

หรือคำสั่ง fseek(fptr,10, SEEK_SET);
หมายความว่าให้ย้าย file pointer ถัดจากตำแหน่งต้นไฟล์ (BOF) ไปอีก 10 byte

ข้อควรจำ ฟังก์ชัน fseek( ) จะให้ค่าไม่เท่ากับศูนย์ เมื่อไม่สามารถย้าย file pointer ได้

9.8.3 ฟังก์ชัน ftell( )
เป็นฟังก์ชันที่ใช้บอกตำแหน่งของ file pointer ว่าปัจจุบันกำลังชี้อยู่ที่ตำแหน่งใดในแฟ้มข้อมูล โดยฟังก์ชันนี้จะให้ค่ากลับเป็นตัวเลขจำนวนเต็ม

รูปแบบการใช้

ftell( fp );

ตัวอย่างที่ 9.9 แสดงการใช้งาน int position;

position = ftell(fp);
printf(“Position is %d Byte”,position);

เพื่อความเข้าใจเกี่ยวกับการใช้ฟังก์ชัน fseek( ) มาช่วยในการประมวลผลแฟ้มข้อมูลแบบสุ่มมากยิ่งขึ้น ให้ศึกษาจากโปรแกรมตัวอย่างต่อไปนี้

โปรแกรมตัวอย่างที่ 9.9 แสดงการใช้ฟังก์ชัน fseek( ) ช่วยประมวลผลแฟ้มข้อมูลแบบสุ่ม

/* randacss.c */
/* this program for read one student’ s record from data file */

#include<stdio.h> /* FILE, NULL ,etc in this file */ /* บรรทัดที่ 1 */
#include<conio.h> /* clrscr() in this file */ /* บรรทัดที่ 2 */
#include<stdlib.h> /* บรรทัดที่ 3 */
void main(void) /* บรรทัดที่ 4 */
{ /* บรรทัดที่ 5 */
struct { /* บรรทัดที่ 6 */
char name[30]; /* บรรทัดที่ 7 */
char id[20]; /* บรรทัดที่ 8 */
float gpa; /* บรรทัดที่ 9 */
} student; /* บรรทัดที่ 10 */
FILE *fptr; /* บรรทัดที่ 11 */
int recno; /* record number */ /* บรรทัดที่ 12 */
long int offset; /* offset must be long */ /* บรรทัดที่ 13 */
if( (fptr=fopen(“a:student.dat”, “rb”)) == NULL ) { /* บรรทัดที่ 14 */
printf(“Can’t open file “); /* บรรทัดที่ 15 */
exit(1); /* บรรทัดที่ 16 */
} /* บรรทัดที่ 17 */
clrscr(); /* บรรทัดที่ 18 */
printf(“Enter record number :”); /* get record num */ /* บรรทัดที่ 19 */
scanf(“%d”, &recno); /* บรรทัดที่ 20 */
offset = (recno-1)*sizeof(student); /* find offset */ /* บรรทัดที่ 21 */
if( fseek(fptr, offset, 0) != 0 ) /* go there */ /* บรรทัดที่ 22 */
{
printf(“Can’t move file pointer”); /* บรรทัดที่ 23 */
exit(1); /* บรรทัดที่ 24 */
} /* บรรทัดที่ 25 */
fread( &student, sizeof(student), 1, fptr ); /* บรรทัดที่ 26 */
printf(“\nName = %s\n”, student.name); /* บรรทัดที่ 27 */
printf(“Id = %s\n”, student.id); /* บรรทัดที่ 28 */
printf(“GPA = %.2f\n”, student.gpa); /* บรรทัดที่ 29 */
fclose(fptr); /* บรรทัดที่ 30 */
getch(); /* บรรทัดที่ 31 */
} /* end main */ /* บรรทัดที่ 32 */

หมายเหตุ ก่อน run โปรแกรมต้องใส่แผ่นดิสก์เก็ตต์ไว้ในไดร์ฟ a: ที่มีแฟ้ม student.dat ที่เคยสร้างไว้แล้ว เพื่อให้โปรแกรมอ่านข้อมูลจากแฟ้มนี้

ผลลัพธ์ที่ได้จากโปรแกรม

คำอธิบายโปรแกรม
จากโปรแกรมตัวอย่างที่ 9.9 โปรแกรมจะอ่านข้อมูลในเรคอร์ดที่ 2 จากแฟ้มข้อมูลที่ drive a: ชื่อ student.dat ได้เลย โดยที่เราไม่ต้องอ่านเรคอร์ดที่ 1 ก่อน

9.9 สรุปท้ายบท

แฟ้มข้อมูล (data file) คือ แฟ้มที่มีการเก็บข้อมูลที่มีความสัมพันธ์กันมาไว้ด้วยกัน โดยมีการเก็บข้อมูลอย่างต่อเนื่องกันไป ตั้งแต่ต้นแฟ้มข้อมูลไปจนกระทั่งจบแฟ้มข้อมูล โดยที่ผู้เขียนข้อมูลสามารถแบ่งข้อมูลที่ต้องการจัดเก็บลงในแฟ้มเป็น field หรือ record ก็ได้ หรืออาจจัดเก็บข้อมูลตามแนวขนาดเนื้อที่โดยไม่จำเป็นต้องแบ่งข้อมูลในแฟ้ม เป็น field หรือ record ก็ได้ โดยปกติผู้เขียนโปรแกรมภาษา C นิยมแบ่งข้อมูลที่ต้องการลงในแฟ้มเป็น field หรือ record เพราะมีความสะดวกในการเรียกใช้ข้อมูลจากแฟ้มที่ต้องการนอกจากนี้ยังสามาถใช้ โปรแกรม text editor หรือโปรแกรม word processing สร้างแฟ้มข้อมูลที่ต้องการได้อย่างสะดวกรวดเร็ว

การประมวลผลแฟ้มข้อมูลในภาษา C (data file processing in C)
โดยปกติแล้วผู้เขียนโปรแกรมเกี่ยวกับแฟ้มข้อมูลในภาษา C จะมีความต้องประมวลผลแฟ้มข้อมูลอยู่ 3 แบบ คือ
1. การบันทึกข้อมูลในแฟ้มข้อมูล (write data into file) มีขั้นตอนดังนี้
1.1 เปิดแฟ้มข้อมูลด้วยคำสั่ง fopen( ) ตั้งชื่อแฟ้มข้อมูล (file name) พร้อมกับระบุ mode ของการบันทึกข้อมูลลงในแฟ้มเป็น “w”
1.2 บันทึกข้อมูลลงในแฟ้มโดยใช้ฟังก์ชัน putc( ) หรือ fprintf( ) หรือ fwrite( ) บันทึกข้อมูลลงแฟ้ม ขึ้นอยู่กับลักษณะของข้อมูลที่ต้องการบันทึกลงแฟ้มดังนี้

  • ถ้าข้อมูลที่ต้องการบันทึกเป็นตัวอักขระตัวเดียว (single character) ให้ฟังก์ชัน putc( ) เพราะสามารถบันทึกตัวอักขระตัวเดียวได้ดี
  • ถ้าข้อมูลที่ต้องการบันทึกเป็นตัวเลขจำนวนเต็ม (integer) หรือตัวเลขจำนวนทศนิยม (floationg point) หรือสตริง (strings) ให้ใช้ฟังก์ชัน fprintf( ) เพราะสามารถจัดรูปแบบข้อมูลที่บันทึกได้
  • ถ้าข้อมูลที่ต้องการบันทึกเป็นข้อมูลแบบโครงสร้าง (structures) หรือตัวแปรชุด (arrays) ให้ใช้ฟังก์ชัน fwrite( ) เพราะสามารถกำหนดเนื้อที่และจำนวนครั้งของการบันทึกข้อมูลได้
  • 1.3 หลังจากบันทึกข้อมูลลงแฟ้มเรียบร้อยแล้ว จะต้องใช้คำสั่ง fclose( ) ปิดแฟ้มข้อมูลทุกครั้งเพื่อป้องกันความเสียหายที่อาจเกิดขึ้นได้

ข้อมูลควรระวังเกี่ยวกับการบันทึกข้อมูลลงแฟ้ม

ในฟังก์ชัน fopen( ) เมื่อใช้ mode “w” เป็นการเปิดแฟ้มข้อมูลเพื่อบันทึกข้อมูลลงในแฟ้มเท่านั้น ถ้าเป็นแฟ้มข้อมูลเก่าที่เคยเก็บข้อมูลไว้แล้ว จะมีผลทำให้ข้อมูลทั้งหมดในแฟ้มข้อมูลเก่า ถูกลบทิ้งไปโดยอัตโนมัติ แล้วสร้างแฟ้มข้อมูลใหม่ขึ้นมาแทนที่

2. การอ่านข้อมูลขึ้นจากแฟ้มข้อมูลขึ้นมาใช้งาน (read data from file) มีขั้นตอนดังนี้

2.1 เปิดแฟ้มข้อมูลด้วยคำสั่ง fopen( ) ตั้งชื่อแฟ้มข้อมูล พร้อมกับระบุ mode ของการบันทึกข้อมูลลงแฟ้มเป็น “r”
2.2 อ่านข้อมูลขึ้นจากแฟ้มโดยสามารถใช้ฟังก์ชัน getc( ) หรือ fscanf( ) หรือ fread( ) อ่านข้อมูลขึ้นจากแฟ้มได้ ขึ้นอยู่กับลักษณะของข้อมูลที่ต้องการอ่านขึ้นจากแฟ้มดังนี้

  • ถ้าข้อมูลที่ต้องการอ่านขึ้นจากแฟ้มเป็นตัวอักขระตัวเดียวให้ใช้ฟังก์ชัน getc( ) เพราะสามารถอ่านข้อมูลตัวอักขระตัวเดียวได้ดี
  • ถ้าข้อมูลที่ต้องการอ่านขึ้นจากแฟ้มเป็นตัวเลขจำนวนเต็ม หรือตัวเลขจำนวนทศนิยม หรือสตริงให้ใช้ฟังก์ชัน fscanf( ) เพราะสามารถจัดรูปแบบข้อมูลที่อ่านขึ้นจากแฟ้มได้
  • ถ้าข้อมูลที่ต้องการอ่านจากแฟ้ม เป็นข้อมูลแบบโครงสร้าง หรือตัวแปรชุดให้ใช้ฟังก์ชัน fread( ) เพราะสามารถกำหนดขนาดเนื้อที่และจำนวนครั้งของการอ่านข้อมูลขึ้นจากแฟ้มได้

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

ข้อควรระวังเกี่ยวกับการอ่านข้อมูลขึ้นจากแฟ้ม

ในฟังก์ชัน fopen( ) เมื่อใช้ mode “r” เป็นการเปิดแฟ้มข้อมูล เพื่ออ่านข้อมูลขึ้นจากแฟ้มข้อมูลอย่างเดียว ไม่สามารถบันทึกข้อมูลเพิ่มเติมลงไปในแฟ้มได้

3. การเพิ่มข้อมูลลงไปในแฟ้มข้อมูล (append data into file) มีขั้นตอนดังนี้
3.1 เปิดแฟ้มข้อมูล ด้วยคำสั่ง fopen( ) ตั้งชื่อแฟ้มข้อมูลพร้อมกับระบุ mode ของการอ่านข้อมูลจากแฟ้มเป็น “a”

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

ข้อควรระวังเกี่ยวกับการเพิ่มข้อมูลลงแฟ้ม

ในฟังก์ชัน fopen( ) เมื่อใช้ mode “a” เป็นการเปิดแฟ้มข้อมูลสำหรับบันทึกข้อมูลเพิ่มเติมลงไปในแฟ้มได้ โดยที่ข้อมูลที่เพิ่มเข้าไปจะเป็นข้อมูลชุดสุดท้ายของแฟ้มเสมอ

ฟังก์ชันที่ใช้ในการเปิดและปิดแฟ้มข้อมูล
การเปิดแฟ้มข้อมูลในภาษา C สามารถทำได้โดยใช้ฟังก์ชัน fopen( ) ส่วนการปิดแฟ้มข้อมูลสามารถทำได้โดยใช้ฟังก์ชัน fclose( ) ซึ่งมีรายละเอียดการใช้งานแต่ละฟังก์ชัน ดังนี้
1. ฟังก์ชัน fopen( ) เป็นฟังก์ชันที่ใช้ในการเปิดแฟ้มข้อมูลที่ต้องการได้ โดยที่ fopen เป็นฟังก์ชันมาตรฐานที่อยู่ในแฟ้ม stdio.h
2. ฟังก์ชัน fclose( ) เป็นฟังก์ชันที่ใช้ในการปิดแฟ้มข้อมูลเมื่อใช้งานแฟ้มข้อมูลเสร็จแล้ว เช่น เมื่อสิ้นสุดการบันทึก หรืออ่านข้อมูลจากแฟ้มข้อมูลใดจะต้องปิดแฟ้มข้อมูลนั้น เพื่อทำให้ข้อมูลที่ค้างอยู่ใน Buffer ของหน่วยความจำของเครื่อง ถูกนำไปเก็บไว้ในแฟ้มข้อมูล แต่ถ้าเราลืมใช้คำสั่ง fclose( ) เมื่อสิ้นสุดการทำงานของโปรแกรม ภาษา C จะปิดแฟ้มข้อมูลให้โดยอัตโนมัติ แต่อย่างไรก็ตามผู้เขียนโปรแกรมควรใช้ fclose( ) ทุกครั้งที่ไม่ใช้แฟ้มข้อมูลแล้วเพื่อสร้างลักษณะนิสัยที่ดีในการใช้งานแฟ้ม ข้อมูล

การใช้ฟังก์ชัน putc( ) และ getc( )
ฟังก์ชัน putc( ) เป็นฟังชันที่ใช้บันทึกข้อมูลตัวอักขระตัวเดียวลงไปในแฟ้มข้อมูลที่ต้องการ
ฟังก์ชัน getc( ) เป็นฟังก์ชันที่ใช้อ่านข้อมูลตัวอักขระตัวเดียวขึ้นจากแฟ้มข้อมูลที่ต้องการ

การใช้ฟังก์ชัน fprintf( ) และ fscanf( )
ฟังก์ชัน fprintf( ) เป็นฟังก์ชันที่ใช้บันทึกข้อมูล (write) ลงแฟ้มโดยสามารถจัดรูปแบบข้อมูลที่ต้องการบันทึกได้คล้ายกับฟังก์ชัน printf( ) แตกต่างกันตรงที่ printf( ) เป็นฟังก์ชันที่ใช้พิมพ์ผลลัพธ์ออกทางจอภาพแต่ฟังก์ชัน fprintf( ) ใช้บันทึกข้อมูลลงแฟ้ม

ฟังก์ชัน fscanf( ) เป็นฟังก์ชันที่ใช้อ่านข้อมูล (read) ขึ้นจากแฟ้มข้อมูลแล้วนำมาเก็บไว้ในตัวแปรที่ต้องการได้โดยมีการทำงานคล้าย กับฟังก์ชัน scanf( ) แตกต่างกันตรงที่ฟังก์ชัน fscanf( ) เป็นฟังก์ชันที่ใช้อ่านข้อมูลจากแฟ้มข้อมูลแต่ฟังก์ชัน scanf( ) เป็นฟังก์ชันที่ใช้รับข้อมูลจากคีย์บอร์ดแล้วไปเก็บไว้ในตัวแปรที่ต้องการ

การใช้ฟังก์ชัน fwrite( ) และ fread( ) ใช้ได้กับ binary file เท่านั้น

ฟังก์ชัน fwrite( ) เป็นฟังก์ชันที่ใช้เก็บข้อมูลลงแฟ้ม โดยที่การเก็บข้อมูลแต่ละครั้งสามารถกำหนดขนาดของข้อมูลที่ต้องการบันทึกได้
ฟังก์ชัน fread( ) เป็นฟังก์ชันที่ใช้อ่านข้อมูลจากแฟ้ม โดยที่แต่ละครั้งสามารถกำหนดขนาด (size) ของข้อมูลที่ต้องการอ่านได้

ฟังก์ชันที่ใช้ควบคุมตำแหน่งของ file pointer ในแฟ้มข้อมูล
การควบคุมตำแหน่งของ fp (file pointer) ในแฟ้มข้อมูล นิยมใช้กันมากในการประมวลผลแฟ้มข้อมูลแบบสุ่ม (random file access) ซึ่งสามารถให้ fp ไปยังตำแหน่งเริ่มต้นของแฟ้มข้อมูล (BOF =beginning of file) หรือ ตำแหน่งใดตำแหน่งหนึ่งในแฟ้มข้อมูลได้
ฟังก์ชันที่ใช้ควบคุมตำแหน่ง file pointer มีดังนี้
ฟังก์ชัน rewind( ) เป็นฟังก์ชันที่ใช้ย้ายตำแหน่งของ file pointer ไปยังตำแหน่งเริ่มต้นของแฟ้ม
ฟังก์ชัน fseek( ) เป็นฟังก์ชันที่ใช้ย้ายตำแหน่งของ file pointer ไปยังตำแหน่งที่ต้องการในแฟ้มข้อมูลโดยจะต้องกำหนดจุดเริ่มต้น (origin) ของ file pointer และค่า offset
ฟังก์ชัน ftell( ) เป็นฟังก์ชันที่ใช้บอกตำแหน่งของ file pointer ว่าปัจจุบันกำลังชี้อยู่ที่ตำแหน่งใดในแฟ้มข้อมูล โดยฟังก์ชันนี้จะให้ค่ากลับเป็นตัวเลขจำนวนเต็ม


พอยเตอร์
พอยเตอร์ (Pointer)

พอยเตอร์ คือต้นฉบับของชนิดข้อมูล ที่สร้างจากข้อมูลมาตรฐานชนิดหนึ่งค่าของมันคือตำแหน่ง Address อยู่ในหน่วยความจำคอมพิวเตอร์ ใช้สำหรับกำหนดค่ามาจากความคิดพื้นฐานของ Pointer Constants
Pointer Values
Pointer Values คือ ตำแหน่ง Address ของตัวแปรซึ่งถ้าต้องการกำหนดค่าทางคีย์บอร์ดต้องใช้เครื่องหมาย & ตัวอย่างเช่น

ตัวแปรพอยเตอร์ (Pointer Variable)

ถ้ามีผู้ใช้ Pointer Constant และ Pointer Value ผู้ใช้ก็สามารถมี Pointer Variable ที่สามารถบรรจุ Address ของตัวแปรหนึ่งให้กับตัวแปรหนึ่งได้

ในรูปแสดงให้เห็นว่า ตัวแปร a มีค่า -123 และตัวแปร a อยู่ในตำแหน่งที่ 234560 ในหน่วยความจำ แม้ว่าตำแหน่งจะเป็นค่าคงที่ แต่ค่าเหล่านี้สามารถเปลี่ยนแปลงได้เมื่อโปรแกรมทำงานแล้ว ซึ่งในรูปจะมีตัวแปรพอยเตอร์ p ค่าของมันในตำแหน่งนี้คือ 234560 ความหมายคือ p ชี้ไปยังตำแหน่ง a
ผู้ใช้สามารถกำหนดตำแหน่ง Address ของตัวแปร ให้กับตัวแปรพอยเตอร์ได้มากกว่าหนึ่งในรูปนี้มีตัวแปร a และตัวแปรพอยเตอร์ p และ q แต่ละพอยเตอร์จะมีชื่อและตำแหน่งที่เป็นค่าคงที่หมายความว่า p และ q ชี้ไปยังตัวแปร a และตัวแปรพอยเตอร์ที่ชี้ไป Address ของตัวแปรเดียวกันสามารถมีได้ไม่จำกัดจำนวนการเข้าถึงตัวแปรพอยเตอร์
การเข้าถึงพอยเตอร์จะต้องใช้ตัวดำเนินการ Indirection หรือ * ตัวอย่างเช่น การเข้าถึงตัวแปรพอยเตอร์ที่ p ชี้อยู่สามารถเขียนได้ดังนี้
*p
อีกตัวอย่างหนึ่งถ้าเราต้องการบวก 1 ให้กับตัวแปร สามารถทำได้เช่นถ้ามีพอยเตอร์ p และกำหนดให้ p=&a เขียนชุดคำสั่งได้ดังนี้
a++, a=a+1; *p=p+1;(*p)++;
จากตัวอย่างนี้ผู้ใช้ต้องวงเว็บตามตัวอย่าง ไม่เช่นนั้นโปรแกรมจะผิดพลาดเพราะนิพจน์ Postfix แบบเพิ่มค่ามีลำดับความสำคัญอยู่ที่ 16 แต่เครื่องหมาย * มีความสำคัญอยู่ที่ 15 ถ้าไม่ใส่วงเล็บจะเพิ่มค่า p เก็บอยู่ไปอีก 1 ก่อน แล้วจึงไปนำค่าในตำแหน่งที่อยู่ใหม่ออกมาแทน

เครื่องหมาย Indirection (*) และ Address (&) เป็นเครื่องหมายตรงกันข้าม เมื่อนำมารวมกัน เช่น *&x ก็จะมีความหมายเท่ากับ x นั่นเอง
การประกาศและกำหนดลักษณะของพอยเตอร์
การประกาศและกำหนดลักษณะของตัวแปรพอยเตอร์จะใช้เครื่องหมาย Indirection เมื่อทำตามแล้วพอยเตอร์จะยังไม่ชี้ไปยังตัวแปรใด

การประกาศตัวแปรพอยเตอร์แบบต่าง ๆ ที่มีข้อมูลตรงตามชนิดข้อมูล และพอยเตอร์ที่ประกาศจะมีชนิดข้อมูลดังนี้ p เป็นตัวอักษร (Character) , q เป็นตัวเลขจำนวนเต็ม (Integer) และ r เป็นเลขทศนิยม (Floating-point)

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

ปัญหา คือ ผู้ใช้ไม่ทำการกำหนดค่าให้กับตัวแปรเหล่านั้น เช่น
Int a; /*ตัวแปรชนิด int*/
Int *p = &a; /*pมีค่าของ Address*/
*p = 89 /*กำหนดค่า 89 ให้ a*/
และถ้าต้องการให้พอยเตอร์ชี้ไปที่ค่า NULL ก็สามารถทำได้ดังนี้
Int *p = NULL
เมื่อกำหนดพอยเตอร์ให้เป็น NULL เท่ากับผู้ใช้ได้ใช้ Address ที่ 0

โปรแกรม 9-2 แสดงการทำงานของพอยเตอร์

โปรแกรม 9-2 การบวกเลข 2 ตัวโดยใช้พอยเตอร์

พอยเตอร์กับฟังก์ชัน
การใช้พอยเตอร์กับฟังก์ชัน มี 2 แบบ คือ

1. การใช้พอยเตอร์เป็นพารามิเตอร์ (Pointer as Formal Parameters) จะมีการเรียกฟังก์ชัน

Exchanges ต้องมีตัวแปร 2 ตัวส่งไปให้ในการส่งค่าแบบ Pass-by-value โดยที่ข้อมูลจะไม่ถูกเปลี่ยนในฟังก์ชันที่ถูกเรียก

ถ้าต้องการให้ตัวแปรสลับกัน จะต้องใช้พอยเตอร์ช่วย หรือไม่ก็ประกาศตัวแปรเหล่านั้นเป็น Global

2. ฟังก์ชันที่มีการส่งค่ากลับเป็นพอยเตอร์ (Function Returning Parameters) ฟังก์ชันที่ใช้หาค่าน้อยที่สุดของตัวแปรระหว่างตัวเลข 2 ตัว

โดยในฟังก์ชันจะมีเงื่อนไขในการหาตัวเลขที่น้อยกว่า

Pointer To Pointer
คือการใช้พอยเตอร์ตัวหนึ่งชี้ไปยังอีกพอยเตอร์หนึ่ง การชี้ไปยังตัวสามารถทำได้ไม่จำกัดระดับโดยในแต่ละระดับจะต้องมีเครื่องหมาย Indirection 1 ตัว ตัวอย่างเช่น

แสดงการใช้ Pointers To Pointers

โปรแกรม แสดงการใช้ Pointers To Pointers

แหล่งอ้างอ้างอิง:http://e-learning.snru.ac.th/els/program1/image/banner_01.jpg

http://itd.htc.ac.th/st_it50/it5012/P_1/C/B9.htm

จัดทำโดย : นางสาว กมลลักษณ์ ศรีละคุณ ม.3/1 เลขที่12

นางสาว ธิภาวรรณ ศรีสามารถ ม.3/1 เลขที่19

นางสาว สุนิตา ไชยเดช ม.3/1 เลขที่30

Advertisements

Posted on กุมภาพันธ์ 20, 2012, in Uncategorized. Bookmark the permalink. ใส่ความเห็น.

ใส่ความเห็น

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / เปลี่ยนแปลง )

Twitter picture

You are commenting using your Twitter account. Log Out / เปลี่ยนแปลง )

Facebook photo

You are commenting using your Facebook account. Log Out / เปลี่ยนแปลง )

Google+ photo

You are commenting using your Google+ account. Log Out / เปลี่ยนแปลง )

Connecting to %s

%d bloggers like this: