การเขียนโปรแกรมคอมพวิ เตอร์ :227

บทท่ี 9
โครงสร้างและยเู นียน

นอกจากตวั แปรชุดประกอบขึ้นจากข้อมูลประเภทพื้นฐานอีกประเภทหน่ึง ข้อมูลแบบ

โครงสรา้ ง (Structure) และข้อมูลแบบยเู นียน เป็นชนดิ ข้อมูลท่ีประกอบดว้ ยตัวแปรต้ังแต่ 1 ตวั ขึ้นไป

ซง่ึ ไมจ่ าเป็นตอ้ งเปน็ ข้อมูลประเภทเดียวกนั มกั จะใช้เมื่อต้องการเกบ็ ข้อมูลทเี่ ป็นกลมุ่ เดยี วกัน เช่น

ข้อมูลของนักศึกษา จะประกอบด้วยขอ้ มลู รหสั นักศึกษา ชื่อ-สกุล วชิ าเอก เปน็ ตน้

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

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

รปู แบบของการประกาศข้อมูลโครงสรา้ ง

struct <ช่ือโครงสร้าง> {
<คุณสมบัติ 1> ;
<คุณสมบตั ิ 2> ;

};

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

struct man {

228:การเขยี นโปรแกรมคอมพวิ เตอร์

char name[16];
char surname[21];
int age;
float height;
float weight;
};

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

9.2 การประกาศขอ้ มูลแบบโครงสร้าง

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

รูปแบบท่ี 1

struct {
int x;
int y;
} p1,p2;

รูปแบบที่ 1 เป็นการประกาศรูปแบบโครงสร้างหนง่ึ ข้นึ มา พรอ้ มกบั การประกาศตวั แปรสาหรับ
โครงสรา้ งน้ี 2 ตวั คอื p1 และ p2

รปู แบบที่ 2

struct point {
int x;
int y;
} p1,p2;

รูปแบบท่ี 2 เป็นการประกาศรปู แบบโครงสร้างและต้ังชอ่ื รูปแบบน้ีวา่ point พร้อมกับทาการ
ประกาศตวั แปรสาหรบั โครงสร้างนี้ 2 ตวั คอื p1 และ p2 การประกาศโครงสรา้ งในรปู แบบนีส้ ามารถ
นา โครงสรา้ งนี้ไปใชส้ าหรบั การประกาศตวั แปรใหม่ท่มี ีโครงสรา้ งเหมอื นกบั p1 และ p2 ไดโ้ ดยไมต่ ้อง
ประกาศโครงสรา้ งนี้ใหม โดยหากตอ้ งการประกาศตัวแปร p3 ซ่งึ มโี ครงสร้างรูปแบบเดียวกับ p1 และ
p2 สามารถทา ไดโ้ ดยเพ่มิ คาสงั่ ตอ่ ไปน้ี

การเขยี นโปรแกรมคอมพวิ เตอร์ :229

struct point p3;

โดยวางคาสัง่ น้ีไวท้ ่ีตาแหน่งหลงั คาสั่งประกาศโครงสร้าง point

รปู แบบท่ี 3

struct point {
int x;
int y;
};
typedef struct

รูปแบบท่ี 4

typedef struct {
int x;
int y;
} point;

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

struct point point1;

หากใช้การประกาศโครงสรา้ งในรูปแบบที่ 3 หรอื 4 สามารถประกาศตัวแปรใหมด่ ้วยคาส่ัง

Point point1;

9.3 การอา้ งถงึ สมาชิกของตวั แปรโครงสรา้ ง

การอา้ งถงึ สมาชิกภายใน struct สามารถทาไดใ้ นรูปแบบตอ่ ไปน้ี

structure-name . member

ตวั อยา่ งเช่น เม่ือต้องการอ้างถงึ สมาชิกภายใน struct วา่ อยูต่ รงกบั จุดใดบนแกนโคออดิเนตจะ
ใช้

printf ( “%d, %d”, maxpt.x, maxpt.y );

230:การเขยี นโปรแกรมคอมพวิ เตอร์

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

#include <stdio.h>
typedef struct
{
int x;
int y;
} point;
void main() {
point pt1,pt2 ;
int area;
/* Input Data */
printf("\nEnter rectangle data\n");
printf("\tStart point x : ");
scanf("%d", &pt1.x);
printf("\tStart point y : ");
scanf("%d", &pt1.y);
printf("\tEnd point x : ");
scanf("%d", &pt2.x);
printf("\tEnd point y : ");
scanf("%d", &pt2.y);
area = (pt2.x-pt1.x) * (pt2.y-pt1.y);
printf("\nArea is%d", area);
}

ตวั อยา่ งที่ 9.2 เขียนโปรแกรมเพื่อรบั ข้อมลู ของผ้ใู ช้ซึ่งประกอบดว้ ย ช่ือ นามสกุล ความสูง และน้าหนัก
แล้ว ใหค้ านวณคา่ ดัชนีของน้าหนัก (Body Mass Index : BMI) ซ่งึ สามารถคดิ ไดจ้ ากสตู ร BMI = w /
h2 โดยที่ w แทนนา้ หนักตวั มีหนว่ ยเป็นกิโลกรัม และ h แทนความสูงมีหน่วยเป็นเมตร หากค่า BMI
อย่ใู นช่วง 20-25 ให้ขึ้นข้อความว่า “Normal BMI.” แตห่ ากอยนู่ อกชว่ งดงั กลา่ วให้ขนึ้ ข้อความว่า
“Dangerous BMI.” ให้ใชโ้ ครงสร้างทาหนา้ ท่เี ก็บข้อมูลของผใู้ ช้ คา่ BMI และผลลัพธ์ทไ่ี ด้ และใหแ้ สดง
ขอ้ มูลท้ังหมด

#include <stdio.h>
#include <string.h>
typedef struct
{
char name[16];
char surname[20];
float height;
float weight;
float bmi;

การเขยี นโปรแกรมคอมพวิ เตอร์ :231

char answer[14];
} student;
void main() {
student std;
printf("Enter student data\n");
printf("\tName : ");
scanf("%s", std.name);
printf("\tSurname : ");
scanf("%s", std.surname);
printf("\tHeight (m) : ");
scanf("%f", &std.height);
printf("\tWeight (Kg) : ");
scanf("%f", &std.weight);
std.bmi = std.weight / (std.height * std.height);

if (std.bmi >= 20 && std.bmi <= 25)
strcpy(std.answer, "Normal BMI");
else
strcpy(std.answer, "Dangerous BMI");
printf("\n\nBMI result");
printf("\n%s %s weight %.2f kg. height %.2f", std.name, std.surname,
std.weight, std.height);
printf("\n\tBody mass index %.2f is %s", std.bmi, std.answer);
}

สังเกตท่ีการรบั ข้อมูลของข้อมูลสตริง เชน่ ชอื่ (std.name) และนามสกุล (std.surname) ไม่
ตอ้ งใชเ้ ครื่องหมาย & หนา้ ตัวแปรน้ัน เนื่องจาก name และ surname เป็นตัวแปรชดุ ตัวอกั ขระ การ
อา้ งถึงช่อื จะเป็นการอ้างถึงแอดเดรสน้ันอยแู่ ล้ว แต่ข้อมูลอ่ืน เชน่ นา้ หนกั (std.weight) และความสงู
(std.height) เปน็ ขอ้ มูลพน้ื ฐานจึงต้องมเี ครือ่ งหมาย & นาหน้า

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

ข้อมูลน้ัน โดยทว่ั ไปข้อมูลแบบโครงสร้างจะประกอบข้ึนจากขอ้ มลู หลาย ๆ ชนิด และข้อมูลแตล่ ะชนิด
มักจะมีการจองพนื้ ทใ่ี ชง้ านแตกตา่ งกันเนอื่ งจากการจองพ้ืนทห่ี นว่ ยความจาในระบบส่วนใหญ่จะจอง
แอดเดรส (address) ท่หี ารด้วย 2 หรือ 4 ลงตวั

จากตวั อย่าง
typedef struct {
int num1;
char ch;
int num2;
} alignment;

232:การเขยี นโปรแกรมคอมพวิ เตอร์

alignment example; /* ประกาศตวั แปร */

สมมติใหข้ อ้ มูลประเภท int ซ่ึงจะตอ้ งใชแ้ อดเดรสท่ีหารดว้ ย 2 หรอื 4 ลงตวั ใชพ้ ้ืนที่ 2
ไบตใ์ นการเก็บขอ้ มูลประเภท char จะใชพ้ ้นื ที่เลขที่อยใู่ ดก็ได้ การจองพ้ืนท่ีในหน่วยความจา
ของตวั แปร example จะ
ไดด้ งั รูป

Member num1 ch num2

Byte 0 23 4
offset

จะเห็นวา่ num2 จะไมส่ ามารถใชพ้ ้นื ที่ที่ติดกบั ch ได้ เน่ืองจาก num2 เป็นขอ้ มูลประเภทตวั
เลขท่ีจะตอ้ งใชแ้ อดเดรสในหน่วยความจาที่หารดว้ ย 2 หรือ 4 ลงตวั การจองพ้นื ที่ของตวั แปร
example จึงทาใหเ้ กิดท่ีวา่ งที่ไม่สามารถนามาใชป้ ระโยชนไ์ ด้ เพราะฉะน้นั การประกาศสมาชิก
ของโครงสร้างจะมีผลต่อการใชพ้ ้ืนที่ในหน่วยความจาดว้ ย

9.4 การใชข้ อ้ มลู แบบโครงสรา้ งกับฟงั กช์ นั

การใชง้ านตวั แปรโครงสร้างกับฟังก์ชนั สามารถทาได้หลายลกั ษณะเช่นเดียวกับการใชง้ านตวั
แปรพน้ื ฐาน ทั้งการกใช้ฟังกช์ ันคืนค่าเป็น struct และการส่งอารก์ ิวเมนท์ให้ฟงั กช์ นั เป็นตัวแปร
โครงสร้าง การใช้งานตัวแปรโครงสร้างกบั ฟังกช์ ันสามารถทาได้หลายลักษณะเช่นเดียวกับการใชง้ านตัว
แปร พื้นฐานท่ีการใชฟ้ งั ก์ชันคนื คา่ เปน็ struct และการส่งอาร์กิวเมนทให้ฟังก์ชันเปน็ ตัวแปรโครงสร้าง
แสดงดังตวั อย่างท่ี 9.3

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

#include <stdio.h>
struct point {

int x;
int y; };
struct point readPoint();
void printPoint(struct point);
void main()
{
struct point pt;
pt = readPoint();
printPoint(pt); }

การเขียนโปรแกรมคอมพวิ เตอร์ :233

struct point readPoint() {
struct point p1;
printf("Enter point X : ");
scanf("%d", &p1.x);
printf("Enter point y : ");
scanf("%d", &p1.y);
return (p1);
}
void printPoint(struct point p) {
printf("\n\nPoint X : %d, y : %d", p.x, p.y);
}

ฟังกช์ นั ท่ีมีการคืนค่าเปน็ โครงสรา้ งมรี ปู แบบคือ
struct <ช่ือโครงสร้าง> <ชอื่ ฟังก์ชัน> ( <ค่าทีส่ ง่ มายงั ฟงั ก์ชัน> ) {
struct <ช่อื โครงสร้าง> <ตัวแปรโครงสรา้ งชัว่ คราว>
…..
return( <ตัวแปรโครงสร้างชวั่ คราว> ); }

ดงั ตัวอยา่ งของฟังกช์ นั readPoint() ทมี่ กี ารคนื ค่าเปน็ โครงสร้าง point

struct point readPoint () {
struct point p1;
…
return (p1); }

ฟงั กช์ นั ท่ีมกี ารคนื คา่ โครงสรา้ งมักจะมีตวั แปรโครงสร้างชวั่ คราวทีใ่ ชท้ างานในฟงั กช์ ันนน้ั เสมอ
เมือ่ ฟังก์ชนั ทางานเสรจ็ กจ็ ะทางานคนื คา่ ดว้ ยคาสงั่ return กจ็ ะทาการสาเนาค่าจากตัวแปรโครงสรา้ ง
ช่ัวคราวกลบั ไปยงั ตวั แปรโครงสรา้ งท่เี รยี กใช้ฟังก์ชันน้นั จากตวั อยา่ งจะมีการสาเนาคา่ จากตัวแปร p1
ในฟงั กช์ นั readPoint() กลบั ไปยังตวั แปร pt ในฟังก์ชัน main() เป็น ผลมาจากการเรียกใชใ้ นฟงั กช์ ัน
main() ด้วยคาสัง่

pt = readPoint();

สว่ นฟังกช์ ันทมี่ ีการรบั อาร์กวิ เมนทเ์ ปน็ ตวั แปรโครงสร้างจากในตวั อยา่ งคือ ฟงั ก์ชัน
printPoint() ซ่ึงมีการรับค่าตัวแปรโครงสร้าง pt จากฟังก์ชนั main() ซง่ึ เรียกใชด้ ้วยคาส่ัง

234:การเขยี นโปรแกรมคอมพวิ เตอร์

printPoint (pt);

ในการประกาศฟงั กช์ นั printPoint จะต้องประกาศพารามิเตอร์เปน็ ตวั แปรโครงสรา้ งเพื่อรับ
ค่าของข้อมลู ดังกลา่ วด้วยคาสัง่

void printPoint (struct point p1)

เมือ่ มีการเรียกใชฟ้ ังก์ชนั printPoint() จะมีการสาเนาค่าจากตัวแปรโครงสร้าง pt ในฟังก์ชนั
main() มายังตวั แปร pi ในฟังกช์ ัน printPoint() หลงั จากนน้ั จึงนาคา่ ดังกลา่ วไปใช้งานพจิ ารณา
ตวั อย่างเพิ่มเติมในตวั อยา่ งท่ี 7.4 ซึง่ เป็นการเขียนตัวอย่างท่ี 7.1 ใหม่ในลักษณะของฟังก์ชนั และเพิ่ม
ฟงั กช์ ันการทางานต่าง ๆ

ตัวอยา่ งที่ 9.4 โปรแกรมตัวอยา่ งของการใชฟ้ งั ก์ชนั เกีย่ วข้องกบั จุดบนแกนโคออดเิ นต

#include <stdio.h>

#define MAX_X 200 /* จดุ สงู สดุ ในแนวแกน X ของรูปสเี่ หลย่ี ม */
#define MAX_Y 300 /* จดุ สงู สดุ ในแนวแกน y ของรูปสเี่ หลยี่ ม */

#define YES 1
#define NO 0
struct point
{
int x;
int y; };
struct rectangle { struct point pt1;
struct point pt2; };

/* ฟังก์ชนั เพ่ือใช้ในการกาหนดจดุ เร่ิมต้นของสเี่ หลยี่ มให้กบั โครงสร้าง */

struct point makepoint(int x, int y) {
struct point temp;
temp.x = x;
temp.y = y;
return (temp);}

/* ฟังก์ชนั เพือ่ ใช้ในการบวกคา่ x และ y ของจดุ 2 จดุ */

struct point addpoint(struct point p1, struct point p2) {
p1.x += p2.x;
p1.y+= p2.y;
return (p1); }

/* ฟังก์ชนั เพือ่ ใช้ตรวจสอบวา่ จดุ ของในรูปสเ่ี หลยี่ มหรือไม่ */
/* ถ้าไมอ่ ยจู่ ะคืนคา่ 0 ถ้าอยจู่ ะคนื คา่ ทีไ่ มใ่ ช่ 0 */

การเขียนโปรแกรมคอมพวิ เตอร์ :235

int pinrect(struct point p, struct rectangle r) {
return (p.x >= r.pt1.x && p.x <= r.pt2.x && p.y >= r.pt1.y &&p.y <= r.pt2.y);}
void main() {
struct rectangle screen;
struct point middle, sumPoint, specPoint;
int ans;

screen.pt1 = makepoint(20,30); /* กาหนดจดุ แรกของสเี่ หลยี่ ม */
screen.pt2 = makepoint(MAX_X, MAX_Y); /* กาหนดจดุ ทสี่ องของสเ่ี หลยี่ ม */

printf("\nLower bound : %d, %d", screen.pt1.x, screen.pt1.y);
printf("\nUpper bound : %d, %d", screen.pt2.x, screen.pt2.y);

/* หาจดุ กงึ่ กลางของรูปสเี่ หลย่ี ม */

middle = makepoint((screen.pt1.x+screen.pt2.x)/2, (screen.pt1,y+screen.pt2.y)/2);
printf("\nMiddle point: %d, %d", middle.x, middle.y);

/* หาผลบวกระหวา่ งจดุ แรกและจดุ ท่ี 2 ของสเี่ หลย่ี ม*/

sumPoint = addpoint(screen.pt1, screen.pt2);
printf("\nSum of bound : %d, %d", sumPoint.x, sumPoint.y);

/* รับคา่ จดุ และทดสอบวา่ จดุ นนั้ อยใู่ นรูปสเี่ หลย่ี มท่รี ะบหุ รือไม่ */

printf("\n\nTest point in rectangle");
printf("\nEnter X : ");
scanf("%d", &(specPoint.x));
printf("Enter y : ");
scanf("%d", &(specPoint.y));
ans = pinrect(specPoint, screen);
if (ans == YES)
printf("\nPoint is in rectangle"); else
printf("\nPoint is outside rectangle");
}

9.5 การใชต้ ัวแปรแถวลาดบั เปน็ สมาชิกของโครงสร้าง

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

typedef struct {

char name [16];
char surname[20];
float score [3];

float total; } Student;

236:การเขยี นโปรแกรมคอมพวิ เตอร์

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

Student std={"Somchai", "Jaidee", 10.0, 20.0, 30.0};

printf("%ร", std.surname); /* อ้างถงึ ข้อมลู นามสกลุ ทงั้ หมด เป็ น สตริง */
printf("%c", std .name[0]); /* อ้างถงึ ตวั อกั ษรตวั แรกของชื่อ เป็ น char */
printf("%.2f', std .score[0]); /* อ้างถึงคะแนนสอบครัง้ ท่ี 1 เก็บในตวั แปรชดุ */

ตวั อยา่ งท่ี 9.5 โปรแกรมเพื่อเก็บข้อมูลนักเรียนคนหนงึ่ ประกอบดว้ ย ชือ่ นามสกุล คะแนนสอบแตล่ ะ
คร้งั ตงั้ แต่ครงั้ ที่ 1 ถึง 5 ซง่ึ แบ่งออกเปน็ ครั้งละ 20 คะแนนเทา่ ๆ กนั และคะแนนรวมของนกั เรียนคนน้นั
โปรแกรมจะมีความสามารถต่าง ๆดังน้ี

- รบั ขอ้ มูลชอ่ื นามสกลุ และคะแนนสอบแตล่ ะคร้ังของนักเรียน
- หาคะแนนรวมของนักเรียนคนน้ัน
- หาคะแนนเฉลย่ี ของการสอบแตล่ ะครงั้
- หาว่ามีการสอบครง้ั ใดทนี่ ักเรยี นคนนั้นได้คะแนนน้อยกว่า 10 คะแนนและไดค้ ะแนนเท่าใด

#include <stdio.h>
#define NO_SCORE 5
typedef struct {
char name [16];
char surname[20];
int score [NO_SCORE];
float total; } Student;
void readStudentData(Student *);
void findTotalScore(Student *);
float findAverage(Student);
void findLessThanTen(Student);
void main() {
Student std;
float avg;
readStudentData(&std);
findTotalScore(&std);
avg = findAverage(std);

การเขยี นโปรแกรมคอมพวิ เตอร์ :237

printf("\n\nAverage score is %.2”,avg);
findLessThanTen(std); }
void readStudentData( Student *pStd) {
int i;
printf("Enter student data\n");
printf("\tName : ");
scanf("%s", &pStd->name);
printf("\tSurname : ");
scanf("%s", &pStd->surname);
for (i=0; i<NO_SCORE; i++) {
printf("\tScore %d : ", i+1);
scanf("%d", &pStd->score[i]); }}
void findTotalScore(Student *pStd) {
int i;
printf("\n\nPrint student data");
printf("\n\t%s %s got score ", pStd->name, pStd->surname);
pStd->total = 0.0;
for (i=0; i<NO_SCORE; i++) {
printf("%6d", pStd->score[i]);
pStd->total += pStd->score[i]; }
printf("\n\tTotal score is %.2”,pStd->total); }
float findAverage( Student s) {
return(s.total/NO_SCORE); }
void findLessThanTen(Student s) {
int i,count=0;
printf("\n\nScore less than 10");
for (i=0; i<NO_SCORE; i++) {
if (s.score[i] <10) {
printf("\n\tTest no.%d - %d", i+1, s.score[i]);
count++; }}

if (count==0)/* กรณีท่ีไมม่ กี ารสอบครัง้ ใดได้น้อยกวา่ 10 */

printf(" -> None");
}

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

238:การเขยี นโปรแกรมคอมพวิ เตอร์

ชว่ ยเพราะชว่ ยให้การ บารงุ รักษาโปรแกรมทาไดง้ ่ายขึน้ แต่หากข้อมูลมีปริมาณมากและมีจานวนสมาชิก
ของตัวแปรชุดท่ีไม่ แน่นอนมักจะใช้โครงสร้างข้อมูลประเภทลิสท์ (List) เข้ามาช่วยเน่ืองจากช่วย
ประหยัดเนื้อท่ีหน่วยความจา ได้มากกว่าซ่ึงหารายละเอียดได้ไนหนังสือการเขียนโปรแกรมขั้นสูงและ
หนังสือโครงสร้างข้อมลู ทว่ั ไป ตวั อย่างของการใช้ตวั แปรชดุ ของโครงสร้างไดแ้ ก่

#define STAFF SIZE 100
typedef struct {
char employee_id[4];
char name [16];
char surname[20];
char gender; /* 0 - Male, 1 - Female */
char department 10] ;
float salary; }
Employee ;
Employee staff[ STAFF SIZE];

การอา้ งโดยใช้คาสงั่ ตา่ ง ๆ
staff อ้างถึงตวั แปรชดุ ของโครงสร้าง
staff[i] อ้างถงึ สมาชกิ ตวั ที i ในตวั แปรชดุ
staff[i].name[i] อ้างถงึ ตวั อกั ษรตวั แรกในชื่อของพนกั งานคนท่ี i
staff[i].surname อ้างงถึงนามสกลุ ของพนกั งานคนที่ i
หากต้องการเรยี กใช้งานฟังก์ชันท่ีทางานกับตัวแปรชุดเชน่ ฟังก์ชันการพิมพช์ ื่อพนักงานท้ัง

บริษทั

printEmployee (staff);

รปู แบบฟงั กช์ ันสามารถกาหนดดว้ ย

void printEmployee (Employee emp[ ])

การเขยี นโปรแกรมคอมพวิ เตอร์ :239

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

printEmployee()

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

printPerson ( staff[k]);

รูปแบบฟังกช์ ันสามารถกาหนดด้วย

void printPerson (Employee person)

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

staff[k] = readPerson(); ใช้คกู่ ับฟังกช์ นั Employee readPerson() { ... }

หรือใช้ในลักษณะส่งพอยนเ์ ตอร์ไปยังฟงั ก์ชันได้ดังคาสงั่

readPerson ( &staff[k]); ใชค้ ู่กบั ฟังก์ชนั voidreadPerson(Employee *person)

{ ... }

การกาหนดคา่ เริม่ ตน้ ใหก้ บั ตวั แปรแถวของโครงสรา้ งสามารถทาได้โดย

Person staff[ ] = { { "001", "John", "Henry", 0, "Account", 20000.0 },
{ "002", "Harry", "Ford", 0,Sale", 8000.0 }, { "003",
"Ant", "Park", 1, "Customer", 25 } };

240:การเขยี นโปรแกรมคอมพวิ เตอร์

หากกาหนดในลักษณะดังกล่าวจะได้วา่ ตวั แปรแถวมีขนาดสมาชิกคือ 3 ขอบเขตขอ้ มูลแต่ละ
สมาชิกจะอยูภ่ ายในเครื่องหมาย{} ตวั อยา่ งเพม่ิ เติมของการใช้งานตวั แปรชุดของโครงสร้างแสดงดัง
ตวั อยา่ งที่ 9.6 และ 9.7

ตัวอยา่ งที่ 9.6 โปรแกรมเพือ่ รบั ข้อมูลชือ่ นามสกลุ และอายุของนักเรียนหอ้ งหน่ึงซ่ึงมี 20 คน
โปรแกรมสามารถหาอายุเฉล่ยี ของนักเรยี นทัง้ ห้องหาวา่ มนี ักเรยี นคนใดท่มี ีอายนุ อ้ ยกวา่ อายเุ ฉลย่ี และ
หาชือ่ นกั เรยี นท่ีมอี ายุมากทส่ี ุดและน้อยทสี่ ุดของนักเรยี นในหอ้ งน้นั

#include <stdio.h>

#define MAXSTUDENT 4

typedef struct {

char name [16];
char surname[20];

int age;
} Student;
void readStudent(Student []);
void printStudent(Student []);
float findAverageAge(Student []);
void LessThanAverage(Student [], float);
void findMaxMinAge(Student [], int *, int *);
void printMaxAge(Student [], int);
void printMinAge(Student [], int);
void main()
{
Student student [MAXSTUDENT];
float avg;
int maxAge, minAge;
readStudent(student);

printStudent(student);
avg = findAverageAge(student);

printf("\n\nAverage age is %.2”,avg);

LessThanAverage(student, avg);
findMaxMinAge(student, &maxAge, &minAge);
printMaxAge(student, maxAge);
printMinAge(student, minAge); } "
void readStudent(Student stdarr[])
{
int i;
printf("Enter student data");

for (i=0; i<MAX_STUDENT; i++)

{

printf("\n\tNo.%d , i+1);

printf("\n\tName : ");
scanf("%s", stdarr[i].name);

การเขียนโปรแกรมคอมพวิ เตอร์ :241

printf("\tSurname : ");
scanf("%s", stdarr[i].surname);
printf("\tAge : ");
scanf("%d", &stdarr[i].age); }
}
void printStudent(Student stdarr[])
{
int i;
printf("\n\nStudent data");

for (i=0; i<MAX_STUDENT; i++) {
printf("\n\tNo.%d , i+1);
printf("\tName : %16s", stdarr[i].name);
printf("\tSurname : %20s", stdarr[i],surname);

printf("\tAge : %d", stdarr[i].age); }}
float findAverageAge(Student stdarr[]) {

float sumAge=0.0, avgAge;

int i;

for (i=0; i<MAX_STUDENT; i++) {

sumAge = sumAge + stdarr[i].age;}
avgAge = sumAge / MAX_STUDENT;
return(avgAge); }
void LessThanAverage(Student stdarr[], float avg)
{
int i;

printf("\n\nLess than average age %.2favg);
for (i=0; i<MAX_STUDENT; 1++) {

if (stdarr[i].age < avg)

printf("\n %s %s with %d years old", stdarr[i].name,stdarr [i], surname, stdarr[i].age);

}
}
void findMaxMinAge(Student stdarr[], int *max, int*min)
{
int i, maxldx, minldx;

maxldx = minldx = 0;

for (i=1; i<MAX_STUDENT; i++) {
if (stdarr[i].age > stdarr[maxldx],age)
maxldx = i;
else if (stdarr [i], age < stdarr [minldx], age)
minldx = i; }

*max = stdarr [maxldx], age;
*min = stdarr[minldx].age; }

void printMaxAge(Student stdarr[], int maxAge)
{

int i;
printf("\n\nMaximum age report");
printf("\nMaximum age is %d", maxAge);

242:การเขียนโปรแกรมคอมพวิ เตอร์

for (i=0; I<MAX_STUDENT; i++) {
if (stdarr[i],age == maxAge)

printf("\n\t%s %ร", stdarr[i].name, stdarr[i],surname);

}}

void printMinAge(Student stdarr[], int minAge)
{
int i;
printf("\n\nMinimum age report");
printf("\nMinimum age is %d", minAge);
for (i=0; i<MAX_STUDENT; i++) {
if (stdarr[i].age == minAge)
printf(“\n\t%s %s”,stdarr[i].name, stdarr[i].surname);
}
}

ตวั อยา่ งท่ี 9.7 โปรแกรมคานวณอายุบนดวงดาวอ่นื โดยใชโ้ ครงสร้างและชนดิ ขอ้ มูลอ่นื ๆ ในการคานวณ
อายุ หากอายคุ น 18 ปี แสดงวา่ เป็นการหมุนของโลกรอบดวงอาทติ ย์ผ่านไป 18 รอบเราสามารถ
คานวณ อายุของคนบนดาวดวงอ่นื โดยอาศัยการคานวณด้วยสูตร X = (Y * 365) / D
เมอ่ื X แทนอายุบนดาวทีร่ ะบุ

Y แทนอายุบนโลก
D แทนจานวนวนั ท่ดี าวที่ระบุโคจรรอบดวงอาทิตย์
ไหส้ รา้ งโครงสรา้ งเพื่อเก็บข้อมูลชือ่ ผ้ใู ช้อายบุ นโลกชอื่ ดาวที่ระบุและอายุบนดาวทีร่ ะบุ
นอกจากนใ้ี ห้สรา้ งโครงสรา้ งในลักษณะตัวแปรชดุ เพ่ือเก็บข้อมูลการโคจรรอบดาวต่าง ๆ และกาหนดคา่
เริ่มต้นใหก้ บั ตวั แปรของโครงสรา้ งดงั กลา่ ว ดังข้อมูลต่อไปนี้
ชอื่ ดาวจานวนวนั ทีโ่ คจรรอบดวงอาทิตย์ Mercury 88 Venus 225 Jupiter 4380 Saturn 10767

#include <stdio.h>
#include <conio.h>
#include <string.h>
typedef struct { char name [20] ;
int earthAge;
char targetName[20];
int tar get Age;
} Manlnfo;
typedef struct
{

char name [20] ;
int sunOrbit;
} Planetlnfo;
void readManInfo(ManInfo *);

การเขยี นโปรแกรมคอมพวิ เตอร์ :243

void printManlnfo(Manlnfo);
int selectPlanet(PlanetInfo []);
void computeAge(ManInfo *, Planetlnfo [], int);
void main()
{
Planetlnfo targetPlanet[4]={{"Mercury", 88}, {"Venus", 225}, {"Jupiter",4380}, {"Saturn",
10767}};
Manlnfo man;
int choice;
printf("\nProgram to calculate man's age on other planet");
readManInfo(&man);
choice = selectPlanet(targetPlanet);
computeAge(&man, targetPlanet, choice);
printManlnfo(man);
}
void computeAge(ManInfo *pMan, Planetlnfo target[], int ch) {
int tAge;
strcpy(pMan->targetName, target[ch] .name);
pMan->targetAge = (pMan->earthAge * 365) /target[ch]. sunOrbit;
}
int selectPlanet(PlanetInfo target []) {
int sel; do {
printf("\nSelect 0. Mercury, 1. Venus, 2. Jupiter, 3. Saturn”);
scanf("%d", &sel); } while (sel < 0 II sel > 3);
return(sel);
}
void printManInfo(ManInfo tMan)
{
printf("\n\nResult");
printf("\nName : %s", tMan.name);
printf("\nAge on Earth : %d", tMan.earthAge);
printf("\nAge on %s : %d", tMan.targetName,tMan.targetAge);
}
void readManInfo(ManInfo *pMan)
{
printf("\nEnter your name : ");
scanf("%s", pMan->name);
printf("Enter your age : ");
scanf("%d", &pMan->earthAge);
}

244:การเขยี นโปรแกรมคอมพวิ เตอร์

9.6 ตัวแปรโครงสรา้ งซ้อนโครงสร้าง

สามารถกาหนด structure อยู่ภายในโครงสร้าง structure ได้ (structure ซ้อน structure)
ตัวอยา่ งการประกาศตัวแปรโครงสรา้ งซ้อนโครงสร้าง เชน่

struct names{
char first[LEN];
char last[LEN];

};
struct guy{

struct names handle;
char favfood[LEN];
char job[LEN];
float income;
};

การกาหนดคา่ เริม่ ตน้

static struct guy fellow = {
{ "Franco", "Wathall"},
"eggplant",
"doormate customizer",
15435.00

};

เรยี กใช้ fellow.handle.first จะเทยี บได้กับ "Franco" ซง่ึ เหมือนกับการอ้างดว้ ย
(fellow.handle).first
หมายเหตุ ถ้าไมม่ วี งเล็บใหค้ ิดจากซ้ายไปขวา

การเขียนโปรแกรมคอมพวิ เตอร์ :245

ตัวอย่างท่ี 9.8 ตัวอย่างโปรแกรมประกาศตัวแปรโครงสร้างซอ้ นโครงสร้าง

#include<stdio.h>

#include<conio.h>
struct student
{

char name[20];
int age;
};
struct group
{
struct student one;
struct student two;

};
struct group x = {
{"Kannikar",25},

{"Suraporn",32}

};
void main(void)
{

printf("\n Person One :\n");

printf("Name = %s\n", x.one.name

printf("Age = %d\n", x.one.age);

printf("\n Person Two :\n");

printf("Name = %s\n", x.two.name);

printf("Age = %d\n", x.two.age);

printf("\n\nPress any key back to program...");

getch();
}

246:การเขียนโปรแกรมคอมพวิ เตอร์

9.7 ยูเนียน (Union)

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

union number {/*members are overlaid */

int integer;

float decimal; };

typedef union number Number;

Number data;

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

ตวั อย่างท่ี 9.9 ตัวอยา่ งการใช้สมาชกิ ของยเู นียน

#include <stdio.h>
union number {
int integer;
float decimal; };
typedef union number Number;
void main () {
Number data;
data.integer = 20000;
printf ( "int: %6d, float: %10.4f\n", data.integer, data.decimal);
data, decimal = 123.0;
printf ( "int: %6d, float: %10.4f\n", data.integer, data.decimal);
}

การเขียนโปรแกรมคอมพวิ เตอร์ :247

ผลลพั ธ์ของการทางานจะขึ้นอย่กู บั การทางานแตล่ ะคร้งั แต่การใช้ฟงั กช์ นั printf ครั้งแรกจะให้
คาตอบจานวนเต็มท่ีถูกต้องในขณะที่จานวนจริงจะได้ค่าท่ีไม่สามารถคาดเดาได้และการใชฟ้ งั กช์ ัน
printf ครั้งท่ี 2 จะใหค้ าตอบจานวนจรงิ ทีถ่ ูกต้องในขณะที่จานวนเตม็ จะได้คา่ ที่ไมส่ ามารถคาดเดาได้
เชน่

int: 20000, float: 0.0000
int: 31553, float: 123.0000

การอา้ งถงึ สมาชกิ ภายในยูเนียนสามารถใช้

union-variable, member-name

หรือ

union-variable->member-name

แสดงตวั อย่างการใช้งานดังตวั อยา่ งท่ี 9.12

ตัวอย่างที่ 9.10 โปรแกรมแสดงการใช้งานยเู นียน

#include <stdio.h>
typedef enum {INT, FLOAT } Tag;
union number {/* number pair template */
int integer;
float decimal; };
typedef union number Number;
struct pair {/* tagged number pairs */ Tag tagged;
Number value; };
typedef struct pair Pair;
void print_pair (Pair);
main () {
Pair data;
data, tagged = INT;
data, value, integer = 20000;
print_pair (data);
data.tagged = FLOAT;
data, value, decimal = 123.0;
print_pair (data); }
void print_pair (Pair d) {

248:การเขยี นโปรแกรมคอมพวิ เตอร์

switch ( d.tagged) {
case INT : printf ( "Integer : %d\n", d.value.integer);
break;
case FLOAT : printf ( "Decimal: %f\n", d.value.decimal);
break; }
}

จากตวั อยา่ งมกี ารใช้คาสั่ง enum เป็นคาส่ังช่วยให้ผู้ใช้สามารถกาหนดชนิดข้อมลู ใหมข่ น้ึ ได้เอง

เช่น

enum workday { Monday, Tuesday, Wednesday, Thursday, Friday } ;

เปน็ การกาหนดชนิดข้อมลู ชือ่ Workday ประเภทข้อมลู ท่ีเปน็ ไปได้คอื ข้อมลู ทีอ่ ยู่ใน
เคร่ืองหมายปีกกาทงั้ หมดเมื่อต้องการใช้งานต้องประกาศตัวแปรดังนี้

enum workday today;
today = Monday;
if (today == Monday)
printf( Today is %d", today);

ผลลพั ธ์ท่ีไดจ้ ากการทางานคือ Today is 0 เน่ืองจากการเก็บข้อมูลของ enum จะเกบ็ ใน
ลกั ษณะคล้ายตวั แปรชดุ ของจานวนเตม็ โดยท่ขี ้อมูลตวั แรกมีคา่ เป็น 0 และไล่คา่ เปน็ 12 3 ไปจนกระทัง่
หมดขอ้ มลู และสามารถใช้ enum รว่ มกับคาสั่ง typedef ได้ดังตัวอย่างท่ี 7.12
ในการใชง้ านยูเนียนมักจะใชใ้ นลักษณะที่มีตวั ควบคมุ การทางานขณะน้นั วา่ กาลงั ใช้งานท่ีสมาชกิ
ตัวใดของยูเนยี นเพื่อให้สามารถเรียกใช้ข้อมลู ได้ถูกตอ้ งดังตัวอย่างข้างด้นและมกั จะใช้ยูเนยี นร่วมกบั
ขอ้ มูลโครงสรา้ งเสมอเชน่ ตอ้ งการเกบ็ ข้อมูลผลคะแนนของนกั เรียนซงึ่ แบง่ การคิดเกรดเป็น 2 ลักษณะ
นักเรยี นประเภท A ให้เกบ็ ผลการเรียน
เปน็ ลักษณะรอ้ ยละแต่ถา้ เปน็ นกั เรียนประเภท B ใหเ้ กบ็ ข้อมลู ในลักษณะเกรด A ถงึ F
ประกาศโครงสรา้ ง ไดด้ ังนี้

typedef enum { A, B } Type; typedef struct {
typedef union { char name [16];
float percent; float score;
char grade; Type type;
} Result; Result result;
} Student;

การเขยี นโปรแกรมคอมพวิ เตอร์ :249

สรปุ

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

250:การเขยี นโปรแกรมคอมพวิ เตอร์

แบบฝกึ หดั

1. ออกแบบประเภทข้อมูลแบบโครงสรา้ ง เพ่อื เก็บข้อมลู ประวตั ิของนักศึกษาแต่ละคน โดยเก็บ รหสั
นักศึกษา ชอ่ื ท่อี ยู่ ชอ่ื ผ้ปู กครอง วันเดอื นปีเกดิ เงนิ เดือนท่ีได้รับ

2. เขียนโปรแกรมเพ่ือแสดงผลข้อมลู ดังต่อไปน้ี
ยี่หอ้ ……………………………
รุ่น ……………………………
ประเภท ..………………………….
จานวนประตู ……………………………
กาหนดใหเ้ กบ็ ขอ้ มลู แบบโครงสรา้ งและมีฟังกช์ ันในโปรแกรมย่อยอยา่ งน้อย 3 ฟงั ก์ชันรวมทงั้

ฟังก์ชัน main( ) โดยท่ีฟงั กช์ ันย่อยทา หน้าท่ีรับขอ้ มูล และแสดงผลข้อมลู

3. เขยี นโปรแกรมเก็บขอ้ มลู นักศึกษา แบบ struct ประกอบด้วย ฟลิ ด์ รหสั ช่อื เกรดเฉลี่ย
เขียนโปรแกรมเก็บข้อมูลพนักงาน แบบ struct จานวน 5 คน ประกอบดว้ ยฟิลด์ ช่ือ, ทีอ่ ยู่, เงินเดือน
,โบนสั 3% ของเงนิ เดอื น

1. เก็บประวัตสิ ขุ ภาพของนกั ศึกษา โดยรับ ชอ่ื ,อายุ,bmi โดยท่ี bmi มีฟลิ ด์ สว่ นสูง, นา้ หนกั
สูตรการหา bmi = น้าหนัก / (ความสงู X ความสงู )
ความสูงเปน็ เมตร ตรวจสอบเง่อื นไขวา่
ถา้ bmi > 23 ให้พมิ พ์ “FAT” ถ้า bmi อยู่ระหว่าง 18-23 ใหพ้ มิ พ์ “Smart” ถา้ น้อยกวา่ 18
พมิ พ์ “Thin”

5. เขียนโปรแกรมเพ่ือคานวณคา่ เฉล่ยี ของคะแนนสอบของนกั ศกึ ษา แยกตามประเภทของนกั ศกึ ษา คอื
นักศกึ ษาสงั กดั คณะวทิ ยาศาสตร์ และนักศึกษาคณะอน่ื ๆ หากผใู้ ชป้ อ้ น 1 ให้ถอื ว่าเปน็ นักศกึ ษาคณะ
วทิ ยาศาสตร์ หากป้อนคา่ อนื่ ๆ ให้ถอื ว่าเป็นนักศึกษาคณะอ่ืน โดยกอ่ นการทางานของโปรแกรมให้
สอบถาม จานวนนกั ศึกษาจากผู้ใชโ้ ดยมีจานวนนกั ศกึ ษาไม่เกิน 80 คน กาหนดให้เกบ็ ข้อมูลสังกัดของ
นกั ศึกษาและคะแนนสอบไวใ้ นตัวแปรชดุ ของโครงสร้างใหเ้ รยี บรอ้ ยก่อน แล้วจงึ หาคะแนนเฉลยี่ ของ
นกั ศึกษาสงั กดั คณะวิทยาศาสตร์ และนกั ศึกษาสังกัดคณะอ่ืน
6. เขยี นโปรแกรมในลกั ษณะโครงสรา้ งและยเู นยี น เพ่อื เกบ็ ขอ้ มูลเงนิ รายได้ของพนกั งานในบริษทั แหง่
หนงึ่ ซงึ่ มีพนักงานไมเ่ กิน 50 คน หากมีการป้อนข้อมลู เงินเดอื นของพนกั งานน้อยกวา่ 4,000 บาทจะ

การเขยี นโปรแกรมคอมพวิ เตอร์ :251

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

252:การเขยี นโปรแกรมคอมพวิ เตอร์

เอกสารอ้างองิ

กวิน สินร่งุ เรือง. (2554). คู่มือเรียนการเขยี นโปรแกรมภาษาซี. กรงุ เทพฯ:สานักพมิ พ์แห่งจฬุ าลงกรณ์
มหาวทิ ยาลัย.

ไกรศร ต้ังโอภากุล และกิตนิ ันท์ พลสวสั ดิ์. (2556). คมู่ ือเรยี นเขยี นโปรแกรมภาษา C ฉบับสมบูรณ์
พมิ พค์ รง้ั ท่ี 1 . นนทบรุ ี : ไอดซี .ี

ไกรศร ตัง้ โอภากุล. (2554). ค่มู ือเรียนเขยี นโปรแกรมภาษา C. พมิ พค์ รั้งที่ 1. นนทบรุ ี:ไอดีซ.ี
ฝา่ ยตาราทางวิชาการคอมพวิ เตอร์. (2556). คมู่ อื เรยี นคอมพวิ เตอรแ์ ละการบารงุ รกั ษา. กรุงเทพฯ: ซเี

เอ็ดยเู คชั่น จากดั .
ฝา่ ยตาราทางวิชาการคอมพิวเตอร.์ (2555). คมู่ ือเรยี นคอมพิวเตอร์ภาษาC. กรงุ เทพฯ: ซีเอ็ดยเู คชั่น

จากดั (มหาชน).

ธนญั ชัย ตรภี าค. (2553). คอมพวิ เตอร์และการเขียนโปรแกรม.พิมพ์คร้งั ที่ 2 .กรงุ เทพมหานครฯ:ซีเอด็
ยเู คชัน่ ,

ธีรวัฒน์ ประกอบผล.(2556). คมู่ ือการเขียนโปรแกรมภาษา C ฉบับสมบรู ณ.์ พมิ พ์ครง้ั ที่ 1. กรุงเทพฯ.
สานกั พิมพ์ ซมิ พลิฟาย.

ประหยัด สุพะ. โครงสรา้ งและยเู นียน ( Structures and Unions ). สืบคน้ เม่ือ
12 กมุ ภาพันธ์ 2557, จาก http:// alaska.reru.ac.th/5583709/C7.pdf.

วจิ ักษณ์ ศรสี ัจจะเลิศวาจา และดษุ ฎี ประเสรฐิ ธติ ิพงษ.์ (2545). การเขยี นโปรแกรมภาษาซี.
ภาควชิ าวิทยาการคอมพวิ เตอร์ คณะวทิ ยาศาสตร์ มหาวทิ ยาลยั เชยี งใหม่.

โอภาส เอี่ยมสริ ิวงศ์ . (2552). การเขียนโปรแกรมด้วยภาษา C.กรุงเทพฯ: ซีเอ็ดยูเคช่ัน.
ศริ ิชยั นามบรุ .ี (2557). (ออนไลน)์ . แหล่งท่ีมา :

http://www.scribd.com/doc/33490603/ สบื ค้นเมอื่ (14 กุมภาพันธ์ 2557)

อรพิณ ประวัติบรสิ ทุ ธ์.ิ (2556). คู่มือเขียนโปรแกรมดว้ ย ภาษา C ฉบบั สมบรู ณ.์ กรงุ เทพมหานคร :
บริษัท โปรวิชนั จากดั .

http://alaska.reru.ac.th/5583709/C6.pdf สบื คน้ เมอื่ (12 กมุ ภาพันธ์ 2557)
http://krooa.files.wordpress.com/2013/07/cprogrammingv2-6.pdf สืบคน้ เม่ือ (15 มนี าคม

2557)
http://kanokwan.sru.ac.th/e-learning/12.php สืบค้นเมอื่ (25 เมษายน 2557)
www.pdp.ac.th/30220/ppt/slide02_array.ppt สืบค้นเมอ่ื (25 เมษายน 2557)

www.it.nrru.ac.th/krit/411101/Chap_10.ppt สืบค้นเมื่อ (25 เมษายน 2557)

รายวชิ า การเขียนโปรแกรมคอมพวิ เตอร์:253

แผนบรหิ ารการสอนประจาบทท่ี 10

การโปรแกรมคอมพิวเตอร์
Computer Programming

หัวข้อเน้อื หา

10.1 แฟม้ ขอ้ มูลเบือ้ งตน้
10.2 แฟม้ ขอ้ มลู แบบเข้าถงึ โดยตรง
10.3 แฟม้ ข้อมลู แบบลาดับ
10.4 แฟม้ ข้อมลู แบบระเบียน
10.5 ฟังก์ชันในการทางานร่วมกบั ไฟล์

วัตถุประสงค์เชงิ พฤติกรรม

1. เพ่อื ใหผ้ เู้ รียนมีความเข้าใจเก่ยี วกบั แฟ้มข้อมลู
2. เพือ่ ให้ผเู้ รยี นอธบิ ายเกี่ยวกับแฟม้ ข้อมลู ได้
3. เพื่อให้ผเู้ รยี นมีความเขา้ ใจเก่ยี วกับโครงสร้างข้อมูลแบบแฟ้มขอ้ มูล
4. เพื่อให้ผเู้ รียนเขยี นโปรแกรมเกีย่ วกบั แฟม้ ข้อมลู ได้
5. เพ่ือให้ผูเ้ รียนมีความเข้าใจเก่ียวกับแฟม้ ข้อความ
6. เพื่อให้ผูเ้ รยี นอธบิ ายเกี่ยวกับแฟม้ ข้อความได้
7. เพ่อื ใหผ้ เู้ รียนฟังก์ชันในการทางานรว่ มกับแฟ้มขอ้ มลู ได้
8. เพือ่ ใหผ้ เู้ รยี นเขยี นโปรแกรมโดยใชฟ้ งั ก์ชันในแฟ้มขอ้ มูลได้

วธิ ีสอนและกจิ กรรมการเรียนการสอนประจาบท

1. บรรยายเน้ือหาในแต่ละหัวข้อ พร้อมยกตวั อย่างประกอบ
2. ศกึ ษาจากเอกสารประกอบการสอน
3. ผูส้ อนสรุปเนอื้ หา
4. ทาแบบฝึกหดั เพือ่ ทบทวนบทเรียน
5. ผ้เู รียนถามขอ้ สงสัย
6. ผสู้ อนทาการซักถาม

254 : แฟม้ ขอ้ มูล

ส่อื การเรยี นการสอน

1. เอกสารประกอบการสอนวิชาการโปรแกรมคอมพวิ เตอร์
2. ภาพเลอื่ น (Slide)
3. บทความจากหนงั สือ หรือเวบ็ ไซต์ตา่ งๆ
4. เคร่ืองคอมพิวเตอร์

การวัดผลและการประเมิน

1. ประเมินจากการซกั ถามในชน้ั เรยี น
2. ประเมินจากความร่วมมือและความรบั ผิดชอบต่อการเรยี น
3. ประเมนิ จากการทาแบบฝึกหัดทบทวนทา้ ยบทเรียน
4. ประเมินจากการฝกึ ปฏบิ ัติ

การเขยี นโปรแกรมคอมพวิ เตอร์:255

บทท่ี 10

แฟม้ ขอ้ มูล

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

10.1 พืน้ ฐานการทางานกับไฟล์

ไฟล์แบง่ ออกเปน็ 2 ประเภทดงั นี้
10.1 แฟ้มขอ้ ความ (Text files) เปน็ ไฟล์ทเ่ี ก็บข้อมลู ในรูปแบบตวั อักษร และจะแยกแต่ละ่
บรรทัดของเทก็ ซไ์ ฟลอ์ อกจากกนั ดว้ ย “\n” ตัวอย่างนามสกลุ ของ ชนดิ ของแฟ้มข้อมูลText File
มีดังนี้
-.txt ไฟลข์ ้อความ
-.bak ไฟล์สารอง
-.log ไฟล์ Log
-.ini ไฟลเ์ ก็บคา่ profile
-.c ไฟลซ์ อรส์ โคด้ โปรแกรมภาษา C
-.php ไฟล์ซอร์สโค้ดโปรแกรมภาษา PHP

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

256 : แฟ้มข้อมลู

1. เริ่มต้นใชง้ านเท็กซไ์ ฟล์
การทางานกบั ไฟล์จะต้องทาผ่านตัวอ้างอิงไฟล์ ซ่งึ ตัวอ้างองิ ไฟลส์ ามารถกาหนดขึ้นไดโ้ ดยใช้
ชนิดขอ้ มลู FILE ในการกาหนด ดังนี้

รูปแบบ
FILE *ช่อื ที่กาหนดขน้ึ เพื่ออ้างอิงไฟล์;

ซง่ึ การกาหนดลกั ษณะนัน้ จาเปน็ ตอ้ งรวมเฮดเดอร์ไฟล์ stdio.h เข้าไวใ้ นการแปลโปรแกรม
รวมดว้ ย

2. การเปดิ และการเปดิ เท็กซ์ไฟล์
รูปแบบ

FILE*(“ชือ่ แฟ้มท่ตี ้องการเปิดใช้งาน”,”mod”);

เม่อื โปรแกรมส่ัง fopen() จะหมายถึงโปรแกรมนไี้ ด้ส่ังให้มีการเปดิ ไฟล์ขน้ึ เพ่อื ทาการใดๆ
ตามทรี่ ะบุไว้ในส่วนของ mode ซ่งึ โหมดการทางานของเท็กซ์ไฟล์แบ่งออกเป็น 6 ประเภทดง้ั นี้

กำหนดตำแหนง่ ไปที่ตำแหนง่ เร่ิมต้นของไฟล์เพื่ออำ่ นข้อมลู
(1) mode “r”

abcdef g

(2) mode “w” กาหนดตาแหน่งไปทต่ี าแหน่งเริม่ ตน้ ของไฟล์เพ่ือเขียนข้อมูลทับไฟล์

เดิม ข้อมHลู ทeี่ต้lอlงoเขยี น Hello

a b c d e f ghi

(3)mode “a” กาหนดตาแหนง่ ไปตาแหน่งสุดทา้ ยของไฟลเ์ พ่ือเขียนข้อมูลตอ่ ท้ายขอ้ มลู
เดิม ข้อมลู ท่ีต้องเขียน

a b c d e f ghi Hello a b c d e f ghiHello

การเขียนโปรแกรมคอมพวิ เตอร์:257

1. รูปแบบคาส่ังท่ีใชใ้ นการปิดแฟ้มแบบเท็กซ์ไฟล์

รูปแบบ
int fclose(ชื่อท่ีกาหนดขึน้ เพอื่ ใชอ้ ้างองิ ไฟล์);

ตวั อยา่ งที่ 10.1 ตวั อย่างโปรแกรมแสดงการเปดิ ไฟลใ์ นโหมด “w”

#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
main()
{

FILE *fp;
fp=fopen(“DATA.DAT”, “w”);
if (fp==NULL){

printf(“Cannot open DATA.DAT\n”);
exit(1); }
fclose(fp);
getch();
}

4. การอ่านเท็กซ์ไฟล์
ฟังกช์ ันทใ่ี ช้อ่านข้อมูลแบบตัวอักษรจากไฟล์ ได้แก่ getc() และ fgetc() ซ่ึงจะทาการอา่ นขอ้ มลู
คร้ังละ 1 ตวั อกั ษรจากไฟล์ ซ่ึงหากส้ินสดุ ไฟล์แล้ว ทัง้ สองฟังกช์ น่ั กจ็ ะคนื คา่ EOF กลับมา
รูปแบบ

int getc (ชื่อท่ีกาหนดข้นึ เพ่ือใช้อา้ งอิงไฟล์);
int fgetc (ชื่อทก่ี าหนดข้นึ เพื่อใชอ้ ้างอิงไฟล์);

1. การเขียนเท็กซ์ไฟล์
ฟงั ก์ชันท่ีใชเ้ ขียนข้อมลู แบบตัวอักษรจากไฟล์ ได้แก่ putc() และ fputc() ซง่ึ จะทาการเขียน
ขอ้ มูลคร้ังละ 1 ตวั อักษรลงไฟล์ ซ่งึ สาหรับฟังกช์ ่ัน fputc() นั้นหากเขียนขอ้ มูลไมส่ ารจ็ ก็จะคืนค่า EOF
กลบั มาให้

258 : แฟ้มขอ้ มลู

รูปแบบ
int putc (ตวั อกั ษรที่จะเขยี นลงไฟล,์ ชื่อที่กาหนดข้ึนเพ่ือใช้อา้ งองิ ไฟล์);
int fputc (ตัวอกั ษรทจี่ ะเขยี นลงไฟล์,ชือ่ ทีก่ าหนดขนึ้ เพ่ือใชอ้ ้างอิงไฟล์);

ตวั อย่างที่ 10.2 ตัวอยา่ งโปรแกรมแสดงการทางานกบั ไฟล์ด้วยฟังก์ชน่ั putc(),fputc() และ
getc(),fgetc()

#include<stdio.h>
#include<conio.h>
#include<process.h>
main(){

FILE *fp1,*fp2;
char ch ;
if ((fp1=fopen(“oneChar.det”, “w”))==NULL){

printf(“Cannot open file oneChar.det for write\n”);
exit(1); }
if ((fp2=fopen(“oneChar.det”, “w”))==NULL){
printf(“Cannot open file oneChar.det for write\n”);
exit(1); }
printf(“Please enter one character”);
ch=getch();
if (putc(ch,fp1)==EOF){
printf(“Error to write data to file\n”);
exit(1); }
printf(“\nPlease enter one character :”);
ch=getche();
if (fputc(ch,fp1)==EOF){
printf(“Error to write data to file\n”);
exit(1); }
fclose(fp1);
if ((ch=getc(fp2)) !=EOF)
printf(“\nFirst Character in text file is %c\n”,ch);
if ((ch=fgetc(fp2)) !=EOF)
printf(“Secoud character in text file is %c\n”,ch);
fclose(fp2);
getch();
} if (fputc(ch,fp1)==EOF){
printf(“Error to write data to file\n”);
exit(1); }
fclose(fp1);
if ((ch=getc(fp2)) !=EOF)
printf(“\nFirst Character in text file is %c\n”,ch);
if ((ch=fgetc(fp2)) !=EOF)
printf(“Secoud character in text file is %c\n”,ch);

การเขียนโปรแกรมคอมพวิ เตอร์:259

fclose(fp2);
getch();
}

ฟงั ก์ช่ัน fscanf()
รูปแบบการอ่านข้อมูลจากไฟล์ คือ

รูปแบบ

int fscanf(ชอ่ื ท่ใี ช้อ้างองิ ข้ึนเพื่อใชอ้ ้างอิงไฟล์,“string format”,data list);
ฟังก์ช่นั fscanf() คลา้ ยกลับฟังก์ชนั่ scanf() ตรงทีฟ่ ังกช์ ่นั ทั้งสองใชใ้ นการรับข้อมูล
เหมอื นกนั แต่ scanf() จะทาการรบั ข้อมูลมาจากคีย์บอร์ด ส่วน fscanf() จะรบั ข้อมลู โดยการอา่ นจาก
ไฟล์

ฟังกช์ ัน่ fprintf()
รปู แบบ
int fprintf(ช่อื ทใ่ี ช้อ้างองิ ขึน้ เพ่อื ใชอ้ ้างอิงไฟล์,“string format”,data list);

ฟังกช์ ัน่ fprintf() คลา้ ยกลับฟังกช์ ่นั fprintf() ตรงท่ีฟังก์ชันท้งั สองใช้ในการแสดงผล
ขอั มลู เหมือนกนั แต่ printf() จะแสดงผลขอ้ มูลออกจากจอภาพ สว่ น fprintf() จะแสดงผล
ขอ้ มูลโดยการเขยี นข้อมลู ลงไฟล์

10.1.2 แฟ้มแบบไบนารี (Binary files) เปน็ ไฟลท์ ่เี ก็บข้อมูลในรูปแบบเฉพาะของคอมพิวเตอร์
ซึง่ ขอ้ มูลทเี่ กบ็ ลงในไบนารไี ฟล์อาจเปน็ จานวนเต็ม เลขจานวนจรงิ ตัวอักษร อาร์เรย์ หรือสตรคั เจอร์ก็
ได้ตัวอย่างไฟล์ท่ีเกบ็ ข้อมลู แบบไบนาร่ี โดยจะเกบ็ ข้อมูลเป็นไบต์ เช่น

-ไฟลร์ ปู ภาพ เชน่ bmp,jpg,gif
-ไฟลเ์ อกสาร ของโปรแกรมต่างๆ .doc , .xls , .ppt , .rdw
-ไฟล์หนังและไฟล์เพลง เชน่ .wav , .mp3 , .wma , .wmv
-ไฟลโ์ ปรแกรม เช่น .exe , .dll
การทางานของไฟล์สามารถอ่านหรือเขียนข้อมูลในไฟล์ก็ได้ เม่ือส่ังให้อา่ นข้อมูลจากไฟล์แล้วขอ้ มูล
ก็จะถูกสง่ ไฟล์มายังหน่วยความจาเพ่ือแสดงผลข้อมูล และเมื่อสงั่ ใหเ้ ขียนข้อมูลลงไฟล์ ข้อมลู ก็จะสง่ จาก
หนว่ ยความจาไปยังไฟล์เพ่อื ทาการเก็บข้อมูลลงไฟล์ ซง่ึ หน่วยความจาที่กลา่ วถึงน้ีคอื บัฟเฟอร์

260 : แฟม้ ข้อมูล

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

1. การทางานกับไบนารไี ฟล์
เริม่ ต้นใช้งานไบนาร่ีไฟล์ สามารถกาหนดตวั อ้างอิงไฟลข์ ึ้นใชง้ านไดด้ งั นี้
รปู แบบ
FILE*ชอ่ื ท่ีกาหนดข้นึ เพื่อใช้อ้างองิ ไฟล์;

2. การเปดิ และปดิ ไบนารีไฟล์
รูปแบบ
*fopen (“ชอ่ื ไฟล์ทีต่ ้องการเปดิ ใชง้ าน”,”mod”);

โดยโหมดการทางานของไบนารีไฟลแ์ ตกต่างจากการทางานของเท็กซ์ไฟล์ กล่าวคือในแตล่ ะ่
โหมดการทางานของไบนารีไฟลจ์ ะระบตุ วั อักษร ‘b’ตอ่ ทา้ ยไวท้ โ่ี หมดนัน้ ๆด้วย เพ่ือบง่ บอกวา่ เป็นโหมด
การทางานของไบนารีไฟล์ ดงั นี้

ตารางท่ี 10.1 แสดงโหมดการทางานของไบนารไี ฟล์

Mode ความหมาย

Rb เปิดไฟล์แบบไบนารีเพื่ออ่านข้อมูลจากตาแหน่งเรม่ิ ตน้ ของไฟล์ ซ่ึงหากยงั ไม่มี

ไฟล์อยู่กจ็ ะเกิด errorขึ้น

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

Ab เปดิ ไฟล์แบบไบนารีเพื่อเขยี นข้อมูล โดยถ้ามไี ฟลอ์ ยู่แล้วจะเขยี นขอ้ มูลตอ่ ทา้ ย

ข้อมลู ที่มีอยู่แลว้ ในไฟล์ แต่ถา้ ไมม่ ีไฟลจ์ ะสร้างไฟลข์ ้นึ มาใหม่

r+bหรือrb+ เปดิ ไฟลเ์ กา่ เพื่ออา่ นหรอื เขยี นข้อมลู ทับข้อมลู เดมิ

w+b หรือwb+ เปดิ ไฟล์เก่าเพื่ออ่านหรือเขยี นขอ้ มลู ทับข้อมูลเดิม หรือสรา้ งไฟล์ขึ้นมาใหญ่

a+bหรือab+ เปดิ ไฟล์เกา่ เพอ่ื อ่านหรอื เขียนขอ้ มลู ทับข้อมลู เดิม

3. รูปแบบการปดิ แฟม้ แบบบารีไฟล์

รูปแบบ
int fclose(ช่ือทกี่ าหนดขึ้นเพ่ือใชอ้ ้างองิ ไฟล์);

การเขียนโปรแกรมคอมพวิ เตอร์:261

4. การอ่านข้อมูลจากไบนารไี ฟล์ด้วยฟังก์ช่ัน fread()
รปู แบบ
fread(void*ptr,ขนาดข้อมลู ,จานวนข้อมลู ทต่ี ้องการอ่าน,ช่อื ท่ีกาหนดข้ึนเพ่ือใช้อา้ งอิงไฟล์);

โดยฟังก์ชัน fread() จะทาการอ่านข้อมูลตามจานวนไบต์ท่ีระบุ เชน่ ระบุ Char a[80];
Fread(a,sizeof(char),3,fp);

หมายถึง ฟังก์ชน่ั fread() จะอา่ นข้อมลู ตามจานวนไบตท์ ี่ระบุ โดยในทีน่ ีร้ ะบุขนาดของข้อมลู ท่ี
ตอ้ งการอ่านเปน็ sizeof(char) ซึง่ มขี นาดเท่ากับ 1 ไบต์ และระบุจานวนที่ต้องการอ่านเป็น 3 ด้ังน้นั
จะทาการอา่ นขอ้ มลู ท้ังหมด 1*3=3 ไบตจ์ ากไฟล์ เปน็ ตน้

5. การเขยี นข้อมลู ลงไบนารไี ฟล์ดว้ ยฟังกช์ ัน fwrite()
รปู แบบ
fwrite(void*ptr,ขนาดข้อมูล,จานวนขอ้ มลู ทีต่ อ้ งการอา่ น,ชอื่ ท่กี าหนดข้ึนเพ่ือใชอ้ า้ งอิงไฟล์);

การทางานฟังก์ชัน่ fwrite() มีหลกั การเดยี วกบั การทางานของฟังกช์ ่ัน fread() ทกุ ประการ
ตวั อย่างโปรแกรมแสดงการทางานกับไฟลด์ ้วยฟังกช์ น่ั fwrite() และfread()

10.2 แฟ้มขอ้ มูลแบบเขา้ ถึงโดยตรง

การใช้งานแฟ้มข้อมูลจากตัวอย่างที่ผ่านมาข้างต้นจะเห็นว่าจะต้องอ่านข้อมูลข้ึนมาทีละลาดับ
จนกว่าจะถึงตาแหน่งสุดท้ายของแฟ้มข้อมูล (EOF) ซ่ึงเป็นการเข้าถึงข้อมูลแบบลาดับข้อเสียของแฟ้ม
ประเภทนคี้ ือจะต้องอา่ นข้อมูลต้ังแต่ตาแหน่งแรกจนกว่าจะถึงตาแหน่งที่ต้องการเสมอซึ่งทาให้เสียเวลา
แฟม้ ขอ้ มูลอกี ประเภทหนง่ึ ท่ีอนุญาตให้มีการเข้าถึงข้อมูลตาแหน่งที่ต้องการได้คือแฟ้มข้อมูลแบบเข้าถึง
โดยตรง (Direct Access File)การใช้แฟ้มประเภทนี้จะต้องรู้โครงสร้างของข้อมูลที่เก็บอยู่ในแฟ้มน้ันซ่ึง
ปกตจิ ะเกบ็ ข้อมูลเปน็ ระเบียนตอ่ เน่ืองกันไปโดยท่ีแต่ละระเบียนมีโครงสร้างข้อมูลท่ีเหมือนกันเสมอด้วย
วิธีน้ีจะได้ว่าแต่ละระเบียนมีขนาดของข้อมูลท่ีเท่ากันเพราะฉะน้ันการอ่านหรือเขียนข้อมูลที่ตาแหน่งที่
ต้องการจะสามารถคานวณตาแหนง่ ท่แี นน่ อนได้เสมอโดยการเล่ือนไฟล์พอยน์เตอร์ไปยังตาแหน่งเริ่มต้น
ของระเบียนทต่ี ้องการอ่านหรือเขียนขอ้ มลู นัน้ แสดง

… พืน้ ทรี่ ะเบียน พืน้ ท่รี ะเบียน พน้ื ท่ีระเบยี น …

ไฟล์ พอยน์ เตอร์

262 : แฟม้ ข้อมูล

แฟ้มข้อมูลทม่ี ีการเข้าถงึ โดยตรงหากลองเปดิ แฟ้มข้อมูลดูเนื้อหาภายในจะพบวา่ ไม่สามารถอ่าน
ข้อมลู ดังกลา่ วได้แฟม้ ในลักษณะน้ีจะใช้ฟังกช์ ัน fread() หรือ fwrite() ในการอ่านและบันทกึ ข้อมูล ซง่ึ
จะกล่าวถึงต่อไปแฟ้มในลักษณะนี้จะมีพนื้ ทรี่ ะเบียไฟล์พอยนเ์ ตอร์เรยี กว่า ไบนารไี ฟล์ (Binary File)
คาสั่งเพ่ิมเติมสาหรบั การจัดการแฟ้มขอ้ มลู แบบเข้าถึงโดยตรงได้แก่

1. ฟงั ก์ชนั่ rewind()
เป็นฟงั ก์ชัน่ ที่ใช้กาหนดให้ file pointer กลบั ไปชที้ ่ีตาแหนง่ เร่ิมต้นของไฟล์
รปู แบบ
void rewind(ชือ่ ท่กี าหนดขึ้นเพ่ือใชอ้ ้างอิงไฟล)์ ;

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

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

long int ftell (ชื่อท่กี าหนดขึ้นเพื่อใชอ้ า้ งองิ ไฟล์);

3. ฟงั ก์ชัน fseek( )
เป็นฟงั กช์ นั ท่ใี ช้ยา้ ยตาแหนง่ ของ file pointer ไปยงั ตาแหนง่ ท่ตี ้องการในแฟ้มขอ้ มลู โดย
จะต้องกาหนดจดุ เร่ิมตน้ (origin) ของ file pointer และคา่ offset
รปู แบบ
int fseek (ช่อื ทีก่ าหนดขนึ้ เพื่อใช้อา้ งองิ ไฟล์,long offset,รูปแบบ);

การกาหนดตาแหน่งของ file pointer ด้วยฟงั ก์ชัน่ fseek( )สามารถทาได้ 3 รูปแบบโดย
กาหนดค่าให้กับพารามิเตอรต์ ัวสุดทา้ ย ดงั ต่อไปนี้

ตารางท่ี 10.2 แสดงรปู แบบการกาหนดค่าให้กับพารามเิ ตอร์ การเขียนโปรแกรมคอมพวิ เตอร์:263

คา่ คงที่ ค่า ความหมาย
นับจากตาแหน่งเริ่มตน้ ของไฟล์
SEEK_SET 0 นับจากตาแหนง่ ปัจจบุ ันของไฟล์
นบั จากตาแหนง่ ท้ายของไฟล์
SEEK_CUR 1

SEEK_END 2

ซ่งึ เมื่อระบุว่าต้องการเล่อื น file pointer โดยนบั จากตาแหน่งใดแลว้ ฟงั ก์ช่ัน fseek( )กจ็ ะ
เรม่ิ ต้นจากตาแหน่งนัน้ เลือ่ นไปตามจานวนไบต์ทร่ี ะบุไว้ใน offset

10.3 แฟ้มขอ้ มลู แบบลาดับ

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

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

หากต้องการอา่ นหรือเขียนข้อมลู โดยกาหนดรปู แบบของการประมวลผลนั้นสามารถทา ได้โดย
เรยี กใช้ฟังก์ชัน fread ( ) เพื่อ การอา่ นข้อมลู และเรียก ใชฟ้ งั กช์ นั fwrite ( ) เพื่อการเขียนข้อมลู การ
ใช้งานฟังกช์ ันท้งั 2 จะคลา้ ยกับการใชง้ านฟังก์ชนั fscanf( ) และ fprintf( )รปู แบบของท้ังสองฟังก์ชัน
เป็นดังนี้

fwrite(dataptr ,sizeof(record struct), 1, fileptr);
fread(dataptr , sizeof(record struct), 1, fileptr);

dataptr คือ ตัวแปรพอยนเ์ ตอรช์ ีไ้ ปยงั ทเ่ี ก็บข้อมลู
record struct คือ ช่อื โครงสรา้ งขอ้ มูลเรคคอรด์ ทต่ี ้องการอ่านหรือเขยี น
fileptr คือ ตัวแปรพอยนเ์ ตอร์ชไ้ี ปยังแฟ้มข้อมลู ที่ต้องการอ่านหรอื เขยี น

264 : แฟม้ ขอ้ มลู

10.4 แฟม้ ข้อมูลแบบระเบยี น

ในการนาข้อมลู ไปใช้งานในการทางานจรงิ ข้อมลู สว่ นใหญ่มกเปน็ ขอ้ มูลแบบเรคคอรด์ เช่น
การจดั เกบ็ แฟ้มข้อมูลสาหรบั จัดเก็บข้อมลู นักศึกษา ส่ิงทเ่ี ราสนใจจัดเกบ็ อาจไดแ้ ก่ รหสั นกั ศึกษา ชอ่ื
นักศกึ ษา ฯลฯ แต่ละรายการทีก่ ล่าวมาจัดเป็นฟิลด์หน่ึงในเรคคอรด์ หากเราต้องการจดั เกบ็ ข้อมูล
เหล่านี้อาจทาได้ดงั ตัวอยา่ งท่ี 8.5 แตก่ อ่ นอืน่ เราควรมาทาความรู้จกั กับฟังก์ชนั สาคญั อีก 2 ฟังก์ชันท่ใี ช้
สาหรบั การจัดการแฟม้ ข้อมูลแบบเรคคอร์ด คือ

ฟังก์ชัน fwrite ( ) และ fread ( )
หากต้องการอ่านหรอื เขยี นข้อมลู โดยกาหนดรูปแบบของการประมวลผลนน้ั สามารถทาไดโ้ ดย
เรียกใชฟ้ งั กช์ ัน fread ( ) เพอื การอา่ นข้อมูล และเรยี กใชฟ้ ังก์ชนั fwrite ( ) เพ่ือการเขยี นข้อมูล การใช้
งานฟังก์ชันท้ัง 2 จะคล้ายกับการใชง้ านฟังก์ชัน fscanf( ) และ fprintf( )รปู แบบของท้ังสองฟงั กช์ ันเปน็
ดังน้ี

fwrite(dataptr ,sizeof(record struct), 1, fileptr);
fread(dataptr , sizeof(record struct), 1, fileptr);

dataptr คือ ตวั แปรพอยนเ์ ตอร์ชีไ้ ปยงั ท่ีเก็บข้อมลู
record struct คือ ชือ่ โครงสรา้ งข้อมลู เรคคอร์ดท่ตี ้องการอา่ นหรือเขียน
fileptr คอื ตวั แปรพอยนเ์ ตอร์ชไี้ ปยังแฟ้มข้อมูลท่ีต้องการอ่านหรือเขยี น

ตัวอย่างที่ 10.3 แสดงการใชแ้ ฟม้ ข้อมูลแบบเรคคอรด์

#include <stdio.h>
#define OK 1
#define ERR 0
#define ARR_SIZE 3
typedef struct {
char ID[8];
char Name[21];
} Student;
int writeData(Student pStudent[ ]) {

FILE *fptr;
int i;

การเขียนโปรแกรมคอมพวิ เตอร์:265

if ((fptr = fopen("student.dat", "w")) != NULL) {
for (i = 0; i < ARR_SIZE; i++)
fwrite(&(pStudent[i]), sizeof(Student), 1, fptr);
fclose(fptr);
return (OK);

} else
return (ERR);

}
int readData(Student *tStudent, int position) {

FILE *fptr;
int size;
if ((fptr = fopen("student.dat", "r")) != NULL) {
fseek(fptr, 0L, SEEK_END); /* go to end of file */
size = ftell(fptr);
if ((position > 0) && (size/sizeof(Student) >= position)) {

fseek(fptr, 0L, SEEK_SET); /* go to begin of file */
fseek(fptr, (position-1)*sizeof(Student), SEEK_SET);
fread(tStudent, sizeof(Student), 1, fptr);
printf("\nID %s, Name %s", tStudent->ID, tStudent->Name);
fclose(fptr);
return (OK);
} else {
printf("\nYour seek postion is out of range");
return (ERR);
}
} else
return (ERR);
}
void main ( ) {
Student aStudent[ARR_SIZE];
Student fStudent;
int i, code, position;
for (i = 0; i < ARR_SIZE; i++) {
printf("\nStudent Data : ");
scanf("%s %s", &(aStudent[i].ID), &(aStudent[i].Name));
}
if (code = writeData(aStudent)) {
printf("\nSelect position : ");
scanf("%d", &position);

266 : แฟ้มขอ้ มลู

if (code = readData(&fStudent, position)) {
printf("\nID : %s, Name : %s", fStudent.ID, fStudent.Name);

}
}
}

จากตวั อยา่ งท่ี 10.3 นจี้ ะทาการอา่ นขอ้ มูลรหสั และช่ือของนักศกึ ษาเข้ามาทีละคนจากทาง
แปน้ พมิ พ์ แลว้ ทาการเก็บไว้ในตัวแปรอาเรย์ ชือ่ aStudent จากนนั กจ็ ะทาการเขียนข้อมลู ลงไปใน
แฟ้มขอ้ มูลชอ่ื student.dat โดยเรยี กใช้งานฟังกช์ นั writedata ซึงเปน็ ฟังกช์ นั ท่ีเขียนขนึ้ มาเอง
เมือ่ ทาการเขียนข้อมลู เสร็จโปรแกรมจะทาการตรวจสอบข้อผิดพลาดในการเขยี นข้อมูล จากประโยค

if (code = writeData(aStudent))

ถ้าหากในขนั ตอนของการเขียนขอ้ มลู ไมเ่ กดิ ข้อผดิ พลาด โปรแกรมจะทางานตอ่ โดยจะรอรับ
ข้อมลู ตาแหนง่ ของเรคคอร์ดที่ผู้ใชต้ ้องการให้แสดง โดยคา่ ที่ปอ้ นน้สี ามารถป้อนได้ตัง้ แต่ 0-2 (เนอื่ งจาก
เรากาหนดขนาดของการรบั ข้อมูลในอาเรย์ไว้ 3 คน) เมอ่ื ผใู้ ชท้ าการป้อนตาแหน่งเรคคอร์ดท่ีตอ้ งการ
เรียบรอ้ ยแลว้ โปรแกรมแสดงค่าข้อมูล ณ ตาแหนง่ ทีผ่ ู้ใช้ระบุโดยทาการเรียกใช้งานฟังก์ชนั readdata
ซึงเป็นฟังกช์ นั ที่เขยี นขน้ึ มาเองเชน่ กัน ตวั อย่างการทางานเช่น หากผ้ใู ช้ปอ้ นข้อมลู ที่ตาแหนง่ นีเ้ ป็น 0
โปรแกรมจะทาการแสดงข้อมูลเรคคอร์ดแรกทบี่ นั ทกึ ไวท้ างจอภาพ เป็นต้น
การคน้ หาข้อมลู ในตวั อยา่ งนี้จะเป็นการคน้ หาโดยใชก้ ารเข้าถงึ โดยตรง (Direct Access) โดยใช้งาน
ฟังกช์ ัน fseekซ่ึงไดอ้ ธบิ ายวธิ การใช้งานในหวั ข้อก่อนหน้านี้แลว้

10.5 ฟังก์ชนั ที่ใช้สาหรับการประมวลผลแฟ้มขอ้ มูล

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

10.5.1 ฟังก์ชัน fopen( )
ในการใชง้ านแฟ้มขอ้ มูลเพื่อการอา่ นหรอื การเขยี นแฟ้มข้อมูล สงิ่ แรกท่ีจาเป็นต้องทาคือการ
เปดิ แฟม้ ขอ้ มูลนั้นก่อนโดยต้องดาเนินการตามขนั้ ตอนดังน้ี
FILE *fileptr;
fileptr = fopen(filename,mode)

การเขียนโปรแกรมคอมพวิ เตอร์:267

ในข้ันตอนแรก ต้องกาหนดตัวแปรพอยน์เตอร์ชีไ้ ปยงั แฟ้มขอ้ มูล ในทน่ี ใ้ี ห้ชือ่ ตัวแปรนว้ี า่
fileptr จากนนั้ ทาการเรียกฟังก์ชัน fopen เพือ่ ทาการเปดิ แฟ้มขอ้ มลู โดยท่ี

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

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

fclose(fileptr);
โดยที่ fileptr คอื ตวั แปรพอยนเ์ ตอรช์ ไี้ ปยังแฟม้ ขอ้ มูลทีต่ ้องการปดิ ทุกคร้งั ที่มกี ารเปดิ
แฟม้ ขอ้ มลู ด้วยฟงั ก์ชนั fopen ( ) ควรจะใช้ฟงั ก์ชนั fclose ( ) ดว้ ยเสมอ

10.5.3 ฟังก์ชนั fgetc( )
ฟงั กช์ นั นที้ างานคล้ายกับฟงั ก์ชนั getchar ( ) ตา่ งกนั ทีฟ่ ังก์ชนั getchar ( ) จะทาการอ่านคา่
อกั ขระทลี ะอักขระจากอุปกรณร์ บั ข้อมลู มาตรฐาน ส่วนฟังกช์ นั fgetc ( ) จะทาการอ่านค่าอักขระทีละ
อักขระจากแฟ้มข้อมูล
รปู แบบของฟงั ก์ชนั fgetc ( ) เป็นดังนี้
ch = fgetc (fileptr) ;

268 : แฟม้ ข้อมลู

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

10.5.4 ฟงั ก์ชัน fputc ( )
ฟงั ก์ชนั นีใ้ ช้สาหรับการเขยี นข้อมลู ทีละอักขระลงในแฟ้มข้อมูล เม่อื เขยี นขอ้ มูลเสร็จ 1 อักขระ
จะทา การเลือ่ นตาแหน่งของพอยน์เตอร์ของแฟม้ ข้อมลู ไป 1 ตาแหนง่
รูปแบบของฟงั ก์ขนั fputc ( ) เป็นดังน้ี

fputc ( ch, fileptr);

โดยที่ ch เป็นตัวแปรที่เก็บค่าอักขระทตี่ ้องการเขียนลงแฟ้มข้อมูล และ fileptr คือตัวแปร
พอยนเ์ ตอร์ชไี้ ปยังแฟ้มข้อมลู ทต่ี ้องการเขยี นขอ้ มูล

10.5.5 ฟงั กช์ นั fgets( )
ฟงั ก์ชนั นีใ้ ชส้ าหรับอ่านข้อมูลในรูปแบบของสตรงิ จากแฟ้มขอ้ มลู โดยในการอา่ นค่าข้อมูลต้อง
ทาการระบุขนาดของข้อมูลท่ีต้องการอ่าน
รูปแบบของฟงั กช์ ัน fgets ( ) เปน็ ดงั น้ี

fgets ( str , len , fileptr );
โดยที่ str คอื เปน็ ตวั แปรใช้สาหรบั เก็บค่าสตรงิ ที่ไดจ้ ากการอา่ นข้อมลู

len คือตัวแปรใช้สาหรับกาหนดขนาดของขอ้ มลู ท่ที าการอ่าน
fileptr คือตวั แปรพอยน์เตอร์ชไ้ี ปยังแฟม้ ข้อมูลท่ีตอ้ งการอา่ น
10.5.6 ฟังกช์ ัน fputs( )
ฟงั กช์ ันนใ้ี ชส้ าหรับการเขยี นข้อมูลในรูปแบบของสตริงลงในแฟ้มขอ้ มูล รปู แบบของฟังกช์ ัน
fputs ( ) เปน็ ดังนี้

fputs ( str , fileptr );

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

การเขยี นโปรแกรมคอมพวิ เตอร์:269

10.5.7 ฟงั กช์ ัน fscanf( ) และ fprintf( )
หากตอ้ งการอา่ นหรือเขียนข้อมลู โดยกาหนดรูปแบบของการประมวลผลน้นั สามารถทาได้โดย
เรยี กใช้ฟังก์ชนั fscanf ( ) เพือ่ การอ่านข้อมูล และเรียกใช้ฟังกช์ นั fprintf ( ) เพ่ือการเขียนข้อมลู

รูปแบบ

fscanf (fileptr , format , arg1,arg2, … );
fprintf (fileptr , format , arg1,arg2, … );

fileptr คอื ตัวแปรพอยนเ์ ตอร์ชไี้ ปยงั แฟ้มข้อมลู ท่ตี ้องการอา่ นหรอื เขยี น
format คอื รูปแบบของการอ่านและเขยี นขอ้ มูล
arg1,arg2,… คือ ตัวแปรท่ีตอ้ งการส่งคา่ เพ่ืออา่ นหรือเขียนขอ้ มูล

10.5.8 ฟงั กช์ นั feof( )
การเก็บข้อมูลในแฟ้มข้อมลู ทุกแฟ้มน้นั จะมกี ารเกบ็ อักขระพิเศษทไ่ี ม่สามารถมองเหน็ ได้คอื
EOF (End Of File) เพ่ือเปน็ ส่ิงบอกให้ทราบวา่ เปน็ จดุ ส้ินสดุ ของแฟ้มขอ้ มูล ฟังก์ชันท่ใี ชต้ รวจสอบวา่
ตาแหนง่ ของไฟลพ์ อยน์เตอร์ปัจจุบันเป็นตาแหนง่ สนิ้ สุดของแฟ้มขอ้ มลู ใชห่ รือไม่คือคือฟังกช์ นั feof ( )

รปู แบบ

retvalue = feof ( fileptr );

fileptr คอื ตวั แปรพอยนเ์ ตอร์ท่ีช้ีไปยงั แฟ้มข้อมูล

retvalue คอื ค่าที่คนื กลบั มาเพ่ือบอกให้ทราบว่าไฟล์พอยน์เตอร์ช้อี ยทู่ ่ีตาแหนง่ EOF หรือไม่
ถ้า retvalue = 0 แสดงวา่ ไฟล์พอยนเ์ ตอร์ไม่ได้ชี้อยทู่ ่ีตาแหน่ง EOF
ถ้า retvalue ≠ 0 แสดงวา่ ไฟล์พอยน์เตอร์ชี้อย่ทู ี่ตาแหน่ง EOF

270 : แฟ้มขอ้ มลู

สรปุ

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

การเขยี นโปรแกรมคอมพวิ เตอร์:271

แบบฝกึ หัด

1. เขยี นโปรแกรมเพอื่ ทาการรับคา่ สตริงจากแป้นพมิ พ์ เพ่ือทา การบันทึกข้อมลู ลงแฟ้มข้อมูลโดย
กาหนดใหส้ ตริงท่ีมีความยาวไมเ่ กิน 100 ตวั อักษร โดยใช้ฟังก์ชัน fputc( )

2. เขียนโปรแกรมเพอื่ ทา การคดั ลอกแฟม้ ข้อมูล ในข้อ 1. ไปจดั เกบ็ ในแฟ้มข้อมลู ใหมช่ ่อื ว่า
Test1.dat

3. เขียนโปรแกรมการทางานกับ Text File ดงั น้ี
3.1 รบั ขอ้ มลู ช่ือและที่อยู่ ของนักศกึ ษา โดยจดั เก็บไว้ในไฟล์ข้อมูลชื่อ d:/old.txt
3.2 คดั ลอกข้อมูลชือ่ และท่อี ยู่ของนักศึกษา ไปไว้ในไฟลใ์ หม่ และให้ยา้ ยไปไว้ท่ี
d:/test/new.txt

4. เขยี นโปรแกรมเพ่ือรับขอ้ มลู สงั กัดและคะแนนสอบของนักศึกษาจานวน N คน และบันทึก
ขอ้ มลู ข้อมลู ไว้ในแฟ้ม student1.dat ใหใ้ ชค้ าสั่ง fprintf( ) ในการบันทึกข้อมูล โดยกาหนดให้
ขอ้ มูลสังกดั ใช้เลขรหัส 1 แทนนักศกึ ษาคณะวิทยาศาสตร์ และเลขรหัสอ่ืน ๆ แทนนักศึกษา
คณะอืน่ และคะแนนสอบของนักศึกษามีคา่ อยู่ในช่วง 0 ถงึ 100 คะแนน

5. เขยี นโปรแกรมเพื่อคานวณเฉลย่ี ของคะแนนสอบของนกั ศึกษา แยกตามประเภทของนักศึกษา
คอื นักศกึ ษาสงั กัดคณะวทิ ยาศาสตร์ และนกั ศึกษาอ่นื ๆ โดยอา่ นข้อมูลจากแฟ้ม
student2.dat

6. เขยี นโปรแกรมเพ่ือรบั ข้อมูลนักศกึ ษาจา นวน N คน โดยเก็บรายละเอียดข้อมูล รหัสนักศกึ ษา
คณะทสี่ ังกดั และชั้น ปโี ดยบนั ทกึ ข้อมลู ในแฟ้ม student2.dat โดยใช้คา ส่งั fwrite( )

272 : แฟม้ ข้อมลู

เอกสารอ้างอิง

กวนิ สนิ ร่งุ เรือง. (2554). คมู่ ือเรียนการเขียนโปรแกรมภาษาซี. กรงุ เทพฯ:สานักพิมพ์แหง่ จฬุ าลงกรณ์
มหาวิทยาลยั .

ไกรศร ต้งั โอภากลุ และกิตินันท์ พลสวัสด์ิ. (2556). คู่มือเรียนเขยี นโปรแกรมภาษา C ฉบับสมบรู ณ์
พิมพ์ครง้ั ท่ี 1 . นนทบุรี : ไอดซี ี.

ไกรศร ตง้ั โอภากุล. (2554). ค่มู อื เรียนเขยี นโปรแกรมภาษา C. พิมพค์ รง้ั ท่ี 1. นนทบรุ ี:ไอดซี .ี
ฝา่ ยตาราทางวชิ าการคอมพิวเตอร์. (2556). คู่มอื เรยี นคอมพิวเตอรแ์ ละการบารุงรกั ษา. กรงุ เทพฯ: ซเี

เอด็ ยเู คช่ัน จากดั .
ฝ่ายตาราทางวิชาการคอมพวิ เตอร.์ (2555). คูม่ อื เรียนคอมพิวเตอรภ์ าษาC. กรุงเทพฯ: ซีเอด็ ยเู คชน่ั

จากัด(มหาชน).

ธนัญชัย ตรภี าค. (2553). คอมพิวเตอร์และการเขียนโปรแกรม.พมิ พค์ รัง้ ท่ี 2 .กรงุ เทพมหานครฯ:ซีเอด็
ยเู คชน่ั ,

ธีรวฒั น์ ประกอบผล.(2556). ค่มู ือการเขียนโปรแกรมภาษา C ฉบบั สมบูรณ์. พิมพ์คร้งั ที่ 1. กรงุ เทพฯ.
สานกั พิมพ์ ซิมพลิฟาย.

ประหยดั สุพะ. โครงสร้างและยูเนยี น ( Structures and Unions ). สบื ค้นเม่ือ
12 กุมภาพันธ์ 2557, จาก http:// alaska.reru.ac.th/5583709/C7.pdf.

วิจกั ษณ์ ศรสี ัจจะเลิศวาจา และดุษฎี ประเสรฐิ ธติ ิพงษ.์ (2545). การเขยี นโปรแกรมภาษาซี.
ภาควิชาวิทยาการคอมพิวเตอร์ คณะวทิ ยาศาสตร์ มหาวิทยาลัยเชยี งใหม.่

โอภาส เอี่ยมสิรวิ งศ์ . (2552). การเขยี นโปรแกรมดว้ ยภาษา C.กรุงเทพฯ: ซเี อด็ ยเู คช่นั .
ศริ ชิ ยั นามบรุ ี. (2557). (ออนไลน์). แหล่งที่มา :

http://www.scribd.com/doc/33490603/ สบื ค้นเม่ือ (14 กุมภาพันธ์ 2557)
อรพิณ ประวตั บิ ริสุทธิ.์ (2556). คู่มือเขยี นโปรแกรมด้วย ภาษา C ฉบับสมบรู ณ.์ กรงุ เทพมหานคร :

บริษทั โปรวิชัน จากัด.

http://alaska.reru.ac.th/5583709/C6.pdf สบื ค้นเมื่อ (12 กุมภาพนั ธ์ 2557)
http://krooa.files.wordpress.com/2013/07/cprogrammingv2-6.pdf สบื ค้นเมื่อ (15 มีนาคม

2557)
http://kanokwan.sru.ac.th/e-learning/12.php สบื คน้ เมอื่ (25 เมษายน 2557)

www.pdp.ac.th/30220/ppt/slide02_array.ppt สืบค้นเมอ่ื (25 เมษายน 2557)
www.it.nrru.ac.th/krit/411101/Chap_10.ppt สบื ค้นเมื่อ (25 เมษายน 2557)

การเขยี นโปรแกรมคอมพวิ เตอร์:273

บรรณานุกรม

ไกรศร ตง้ั โอภากุล และกิตนิ ันท์ พลสวัสด์ิ. (2556). คูม่ อื เรยี นเขยี นโปรแกรมภาษา C ฉบบั สมบรู ณ์
พิมพ์คร้งั ที่ 1 . นนทบรุ ี : ไอดีซ.ี

ไกรศร ตง้ั โอภากลุ . (2554). คมู่ ือเรียนเขยี นโปรแกรมภาษา C. พิมพค์ รง้ั ที่ 1. นนทบุรี:ไอดีซ.ี
ดอนสัน ปงผาบ. (2543). การเขยี นโปรแกรมภาษาซใี นงานควบคมุ . พิมพ์คร้ังที่ 3. กรุงเทพฯ:

สมาคมสง่ เสริมเทคโนโลยี (ไทย-ญป่ี ุน่ ).
ดอนสัน ปงผาบ. (2546). การเขยี นโปรแกรมภาษาซีในงานควบคมุ . พมิ พ์ครั้งท่ี 9. กรงุ เทพฯ:

สมาคมสง่ เสรมิ เทคโนโลยี (ไทย-ญ่ปี ุน่ ).
ธนญั ชยั ตรภี าค. (2553). คอมพวิ เตอร์และการเขียนโปรแกรม.พมิ พ์คร้ังที่ 2 .กรงุ เทพมหานครฯ:ซเี อด็

ยเู คช่นั ,
ธรี วฒั น์ ประกอบผล.(2556). คมู่ อื การเขียนโปรแกรมภาษา C ฉบบั สมบรู ณ์. พมิ พ์ครงั้ ที่ 1. กรงุ เทพฯ.

ซิมพลิฟาย.
ฝ่ายตาราทางวชิ าการคอมพวิ เตอร.์ (2556). คมู่ อื เรยี นคอมพวิ เตอรแ์ ละการบารงุ รกั ษา. กรงุ เทพฯ: ซี

เอด็ ยูเคช่ัน.
ฝ่ายตาราทางวิชาการคอมพวิ เตอร์.(2555). ค่มู ือเรยี นคอมพวิ เตอร์ภาษาC. กรุงเทพฯ: ซเี อ็ดยเู คชั่น.
ประหยัด สุพะ. โครงสรา้ งและยูเนียน ( Structures and Unions ). สบื คน้ เมื่อ

12 กมุ ภาพันธ์ 2557, จาก http:// alaska.reru.ac.th/5583709/C7.pdf.
วิจักษณ์ ศรีสจั จะเลิศวาจา และดษุ ฎี ประเสรฐิ ธิติพงษ์. (2545). การเขียนโปรแกรมภาษาซ.ี

ภาควชิ าวทิ ยาการคอมพิวเตอร์ คณะวิทยาศาสตร์ มหาวทิ ยาลัยเชยี งใหม.่
โอภาส เอ่ียมสริ ิวงศ์ . (2552). การเขยี นโปรแกรมดว้ ยภาษา C.กรุงเทพฯ: ซเี อด็ ยเู คชน่ั .
ศริ ชิ ยั นามบุรี. (2557). (ออนไลน์). แหลง่ ท่มี า :

http://www.scribd.com/doc/33490603/ สืบคน้ เมือ่ (14 กมุ ภาพันธ์ 2557)
อรพิณ ประวตั บิ ริสทุ ธ.์ิ (2556). คู่มือเขียนโปรแกรมด้วย ภาษา C ฉบับสมบรู ณ์. กรุงเทพมหานคร :

บรษิ ทั โปรวิชนั จากดั .

274 :การเขียนโปรแกรมคอมพวิ เตอร์

บรรณานกุ รม

สบื คน้ ออนไลน์
http://alaska.reru.ac.th/5583709/C6.pdf สบื ค้นเม่อื (12 กุมภาพันธ์ 2557)
http://krooa.files.wordpress.com/2013/07/cprogrammingv2-6.pdf สบื ค้นเมื่อ (15 มีนาคม
2557)
http://kanokwan.sru.ac.th/e-learning/12.php สืบคน้ เมอ่ื (25 เมษายน 2557)
www.pdp.ac.th/30220/ppt/slide02_array.ppt สืบค้นเม่อื (25 เมษายน 2557)
www.it.nrru.ac.th/krit/411101/Chap_10.ppt สืบคน้ เม่ือ (25 เมษายน 2557)
http:// app.emaze.com สบื ค้น วันที่ 2 กุมภาพันธ์ พ.ศ. 2557
https:// www.bankersguru.org สืบค้นวันท่ี 7 มีนาคม พ.ศ. 2557
http:// www.radompon.com สบื ค้นวนั ที่ 3 มีนาคม พ.ศ. 2557
http:// www.hitechreview.com สืบค้น วนั ท่ี 17 เมษายน พ.ศ. 2557