CProgrammingV2

การเขยี นโปรแกรมภาษาซี

โดย

วจิ กั ษณ ศรีสัจจะเลิศวาจา
ดษุ ฎี ประเสรฐิ ธติ พิ งษ

ภาควิชาวิทยาการคอมพิวเตอร
คณะวทิ ยาศาสตร มหาวทิ ยาลยั เชยี งใหม

พฤษภาคม 2545



สารบัญ 1
1
บทท่ี 1. แนะนาํ ภาษาซี 1
1.1 แนะนาํ ความเปนมา 5
1.2 รปู แบบโปรแกรมภาษาซี 6
1.3 ตัวแปร 9
1.4 ชนิดขอมูล 11
1.5 การใชต วั แปร 17
1.6 การรบั ขอ มูลและแสดงผลขอ มลู 19
แบบฝก หดั บทท่ี 1 19
21
บทท่ี 2. ตวั ดาํ เนนิ การและนพิ จน 23
2.1 ตวั ดาํ เนินการกาํ หนดคา 24
2.2 ตวั ดาํ เนินการคณิตศาสตร 25
2.3 ตวั ดาํ เนินการกาํ หนดคา แบบผสม 26
2.4 ตวั ดาํ เนินการเพิ่มคาและลดคา 27
2.5 ตวั ดาํ เนินการเปล่ยี นชนดิ ขอมูล 28
2.6 ตวั ดาํ เนินการคอมมา 29
2.7 ตวั ดาํ เนนิ การความสัมพันธ 31
2.8 ตวั ดาํ เนนิ การความเทากัน 33
2.9 ตวั ดาํ เนนิ การตรรกะ 35
2.10 ตวั ดาํ เนนิ การเงอ่ื นไข 35
แบบฝก หดั บทท่ี 2 44
48
บทท่ี 3. คาํ สั่งควบคุม 53
3.1 คาํ สง่ั if 61
3.2 คาํ สงั่ switch 64
3.3 คําส่ัง for 69
3.4 คําส่งั while 69
3.5 คาํ สงั่ do-while 73
แบบฝก หดั บทท่ี 3 77

บทท่ี 4. ฟงกชัน
4.1 แนวความคิดในการออกแบบฟงกชัน
4.2 รปู แบบของฟง กช ัน
4.3 การประกาศโปรโตไทปของฟงกชัน

4.4 ขอบเขต 79
4.5 ฟง กชันแบบเรียกซํ้า 81
4.6 ตวั อยางเพิ่มเติม 84
4.7 ไลบรารีมาตรฐานของภาษาซี 87
แบบฝก หดั บทท่ี 4 90
บทท่ี 5. พอยนเ ตอร 94
5.1 พอยนเตอรกับแอดเดรส 94
5.2 การประกาศตัวแปรพอยนเตอร 95
5.3 การกาํ หนดคาและการอานคาตัวแปรพอยนเตอร 95
5.4 พอยนเตอรและอารก วิ เมนทของฟงกช ัน 99
แบบฝก หดั บทท่ี 5 110
บทท่ี 6. ตัวแปรชุด 113
6.1 รปู แบบการประกาศตวั แปรชดุ 113
6.2 การใชพอยนเตอรกับตัวแปรชุด 125
6.3 ตวั แปรชุดของตัวอักขระ 128
6.4 การคํานวณกับแอดเดรส 131
6.5 ฟง กชันมาตรฐานของสตริง 133
6.6 ตวั แปรชดุ แบบหลายมติ ิ 135
6.7 การกาํ หนดคาเริ่มตนใหกับตัวแปรชุด 2 มิติ 138
6.8 การใชงานตัวแปรชุด 2 มิติ 138
6.9 คอมมานไลนอารกิวเมนท 146
แบบฝก หดั บทท่ี 6 149
บทท่ี 7. โครงสรา งและยูเนยี น 152
7.1 ความรทู ว่ั ไปเกย่ี วกบั โครงสรา ง 152
7.2 การใชงานตัวแปรโครงสราง 153
7.3 การเก็บขอมูลแบบโครงสราง 158
7.4 การใชขอมูลแบบโครงสรางกับฟงกชัน 160
7.5 การใชพ อยนเ ตอรก บั ตวั แปรโครงสรา ง 163
7.6 การใชคาํ สั่ง typedef กบั โครงสราง 167
7.7 การใชต ัวแปรชุดเปนสมาชิกของโครงสราง 169
7.8 ตวั แปรชุดของโครงสราง 172
7.9 ยูเนียน 178
แบบฝก หดั ทา ยบทท่ี 7 182

บทท่ี 8. การจัดการแฟมขอมูล 185
8.1 ฟง กช นั ทใ่ี ชส ําหรบั การประมวลผลแฟม ขอ มลู 185
8.2 การบนั ทกึ ขอ มลู ลงแฟม ขอ มลู 187
8.3 การอานขอมูลจากแฟมขอมูล 188
8.4 แฟม ขอมูลแบบเขาถึงโดยตรง 191
8.5 แฟม ขอ มลู แบบเรคคอรด 192
8.6 อปุ กรณมาตรฐานในการนาํ เขาและแสดงผลขอมูล 195
8.7 การรองรับความผดิ พลาดจากการทาํ งาน 196
8.8 ตวั อยางเพิ่มเติม 197
แบบฝก หดั ทา ยบทท่ี 8 204
205
บรรณานกุ รม



แนะนาํ ภาษาซี

Introduction to C Programming Language 1

ภาษาโปรแกรม (Programming Languages) ทมี่ กี ารคดิ คนขึ้นมาใชกับคอมพิวเตอรนั้นมีหลายพัน
ภาษา แตภ าษาทเ่ี ปน ทร่ี จู กั และเปน ทน่ี ยิ มใชทว่ั ไปนน้ั อาจจะมเี พยี งหลายสบิ ภาษา เชน โคบอล (COBOL)
ปาสคาล (Pascal) เดลไฟล (Delphi) วชิ วลเบสิก (Visual Basic) ซี (C) จาวา (Java) เปน ตน ซึ่งแตละภาษา
สรา งขนึ้ ดว ยวัตถุประสงคที่แตกตางกันและมีจุดเดนของภาษาที่ตางกัน ภาษาซ(ี C Programming Language)
เปนภาษาเชิงโครงสรางท่ีมีการออกแบบโปรแกรมในลักษณะโมดูลที่มีจุดเดนในเร่ืองของประสิทธิภาพการ
ทาํ งานทเ่ี รว็ มีความยืดหยุนในการเขียนโปรแกรมสูง

เนอื่ งจากมผี ผู ลติ คอมไพเลอรเพื่อใชแปลภาษาซีหลายบรษิ ัท ตัวอยางตาง ๆ ทน่ี าํ เสนอในหนงั สอื เลม น้ี
เปน ตวั อยางที่นาํ เสนอโดยใชคอมไพเลอรของ Turbo C เวอรช นั 3.0 ของบรษิ ทั บอรแ ลนด โดยพยายามเขียนใน
รปู แบบทเี่ ปน มาตรฐานหากผูอานนําไปใชกับคอมไพเลอรของบริษัทอื่นจะไดมีการปรับแกไมมากนัก เพื่อใหผ ู
อา นไดเ ห็นภาพการพัฒนาโปรแกรมเชิงโครงสรางอยางชัดเจน

1. ประวัติความเปนมา

ภาษาซไี ดร บั การพฒั นาขน้ึ โดยเดนนสิ รทิ ชี (Dennis Ritchie) ขณะทท่ี าํ งานอยทู เ่ี บลแลบ็ บอราทอรี
(Bell Laboratories) โดยพฒั นาขึ้นจากหลักการพื้นฐานของภาษาบี (B) และบซี พี แี อล (BCPL) ในชวงป ค.ศ.
1971 ถงึ 1973 แตไ ดเพิ่มชนิดขอมูลและความสามารถอื่น ๆ ใหมากขึ้น และนาํ ภาษาซีไปใชพัฒนาระบบปฏิบัติ
การยูนิกซ (UNIX) บนเครื่องคอมพิวเตอร DEC PDP-11 ภาษาซเี ปน ทน่ี ยิ มใชอ ยา งแพรห ลายในชว งตน ทศวรรษ
ท1่ี 980 จนกระทงั่ มคี วามพยายามกําหนดมาตรฐานของภาษาเพื่อใหสามารถใชภาษาซีไดบนเครื่องคอมพิวเตอร
ใด ๆ ในป ค.ศ. 1983 โดย ANSI (The American National Standards Institute) ไดต ั้งคณะกรรมการ X3J11
เพอื่ รางมาตรฐานดังกลาว และไดรับการตรวจสอบและยอมรับโดย ANSI และ ISO (The International
Standards Organization) โดยมกี ารตพี มิ พมาตรฐานของภาษาซีในป ค.ศ. 1990 จากความมีประสิทธิภาพ
และสามารถทาํ งานบนเครอ่ื งคอมพวิ เตอรใ ด ๆ ของภาษาซีจึงไดมีการนาํ ภาษาซีไปใชในการพัฒนาระบบปฏิบัติ
การตา ง ๆ และใชเปนตนแบบของภาษาอื่น ๆ ทส่ี าํ คญั ในปจ จบุ นั เชน ซพี ลสั พลสั (C++) จาวา (Java) เปนตน

2. รปู แบบโปรแกรมภาษาซี

ในการเขยี นภาษาโปรแกรม ผูเขียนโปรแกรมจะตองศึกษารูปแบบพื้นฐานของภาษา และไวยากรณ
ของภาษานน้ั รปู แบบพื้นฐานของภาษาจะเขียนโปรแกรมในลักษณะของโมดูลคือมีการแบงออกเปนสวนยอย ๆ
ทเี่ รียกวา ฟงกชัน (Function) แสดงดังตัวอยางที่ 1.1 และรปู ท่ี 1.1

2
ตวั อยางที่ 1.1 แสดงตวั อยางโปรแกรมภาษาซีเบื้องตน

#include <stdio.h>
void main( ) {

/* Display message to standard output */
printf(“My first program.”);
}

ผลการทํางานของโปรแกรม

My first program.

ระวัง - การพมิ พต วั อกั ษรตัวพิมพใหญและตัวพิมพเล็กตางกัน จะทําใหเ กิดความผดิ พลาด
- ตรวจสอบวามีการพิมพขอความตาง ๆ เหมือนกับตัวอยาง

รปู ท่ี 1.1 แสดงสวนประกอบของโปรแกรมภาษาซีเบื้องตน
สว นประกอบที่ 1 สวนหัว (Header) จะเปน สว นทอ่ี ยทู ต่ี อนตน ของโปรแกรม โดยอยูนอกสว นที่
เรยี กวาฟงกชัน ทสี่ ว นหวั ของโปรแกรมจะประกอบดว ยคําสั่งที่เปนการกาํ หนดคาหรือกาํ หนดตัวแปรตาง ๆ คํา
สงั่ ในท่ขี ้ึนตนดวยสัญลักษณ # เปน คาํ สั่งที่เรียกวา ตัวประมวลผลกอ น (Preprocessor) คอื คาํ สั่งที่จะไดรับการ
ทาํ กอ นทจ่ี ะมกี ารคอมไพลโ ปรแกรม ตัวประมวลผลกอ น ทส่ี าํ คัญของภาษาซีแบงออกเปน 2 ประเภทดงั น้ี

• # include
ในภาษาซจี ะมฟี ง กชนั มาตรฐานทผ่ี ผู ลติ คอมไพเลอรไ ดจ ดั เตรยี มไวให ซึ่งมักจะเกี่ยวของ
กบั การรับขอมูล การแสดงผลขอ มูล การคาํ นวณ และอน่ื ๆ ซึ่งผูเขียนโปรแกรมสามารถ
เรยี กใชง านไดท นั ที โดยไมตองเขียนโปรแกรมแกรมเอง ในตัวอยางจะมีการใชคาํ ส่งั

3

printf( ) ซงึ่ เปน คาํ สงั่ ที่ใชแสดงขอความออกทางอุปกรณแสดงผลมาตรฐาน เชน จอภาพ
คาํ สัง่ printf( ) เปน การเรยี กใชฟงกชันมาตรฐานซึ่งอยูในกลุมที่เรียกวา Standard Input
and Output เมอื่ จะเรยี กใชฟงกชันใดในกลุมดังกลาว จะตองบอกใหคอมไพเลอรไปอาน
คาทอ่ี ยใู นอนิ คลชู ไฟลท ช่ี อ่ื stdio.h มาไวท ส่ี ว นตน ของโปรแกรม โดยใชคาํ สั่ง

#include <stdio.h>
เพราะฉะนั้นผูเขียนโปรแกรมควรจะศึกษาฟงกชันมาตรฐานที่คอมไพเลอรแตละบริษัทได
เตรยี มไวใหวาคําสั่งใดใชคูกับอินคลูชไฟลใด
• # define
ใชส าํ หรบั การกาํ หนดคาคงที่ ตัวอยางเชน

#define YES 1
คาํ สงั่ ดงั กลาวเปน การกําหนดวา หากที่ใดในโปรแกรมมีคําวา YES จะถกู แทนที่ดวยคาทาง
ขวามือ ในที่นี้คือ 1

นอกจากในสว นหัวของโปรแกรมอาจจะมีการประกาศตัวแปร และสว นของการประกาศโปรโตไทปไ วท ส่ี ว นหวั
ของโปรแกรมไดอีกดวย ซึ่งจะกลาวถึงในบทตอ ๆ ไป

สว นประกอบท่ี 2 ฟงกชัน (Function) สว นของฟง กช นั คือสว นของคําสั่งที่บอกใหคอมพิวเตอร
ทาํ งานตา ง ๆ เชน การรับขอมูล การคาํ นวณ การแสดงผล เปนตน โปรแกรมภาษาซีจะประกอบดวยฟงกชัน
ยอ ยหลาย ๆ ฟงกชัน แตจะมีฟงกชันหลักฟงกชันหนึ่งที่ชื่อวาฟงกชัน main( ) เสมอ โดยที่การทํางานของ
โปรแกรมจะตองเริ่มการทํางานจากฟงกชันนี้

กฎพน้ื ฐานทส่ี าํ คัญในภาษาซี
• การพมิ พต วั อกั ษรตัวพิมพใหญและตัวพิมพเล็กในภาษาซีนั้นในผลลัพธที่แตกตางกัน (Case

Sensitive) ตวั อยางเชน หากมีการพิมพ main( ) กลายไปเปน Main( ) กจ็ ะเกดิ ความผิดพลาด
ขึน้
• ฟง กช นั ของภาษาซีจะแบงขอบเขตของฟงกชันแตละฟงกชันดวยเครื่องหมาย { } ในตวั อยางมี
ฟงกชัน void main( ) คาํ วา void จะบอกใหร วู าเมื่อฟงกชันนี้ทํางานเสร็จจะไมมีการคืนคากลับ
ไปยงั สงิ่ ที่เรียกใชงานฟงกชัน ในกรณีของฟงกชัน main( ) กค็ อื จะไมมีการคืนคาใด ๆ กลับไปยัง
ระบบปฏิบัติการ หลังฟงกชันจะตองตามดวย ( ) เสมอ โดยที่ภายในวงเล็บจะประกอบดวย
คา ทสี่ ง เขามายังฟงกชัน ที่เรียกวาพารามิเตอร (Parameter) หรอื อาจจะไมมีคาใด ๆ สงเขามาก็
ได
• คาํ สง่ั ตา ง ๆ ซึ่งตองเขียนอยูในฟงกชันเสมอ แบงเปน 2 สวนคือสวนของการประกาศตัวแปรที่
ตอ งการใชใ นฟง กช ัน และสวนของคาํ สั่งเพื่อทํางานใดงานหนึ่ง ในที่นี้มีเฉพาะคาํ สั่งที่ใชในการ

4

แสดงผลลพั ธอ อกทางจอภาพ คือ printf( ) ใชส าํ หรบั การแสดงผลลพั ธอ อกทางจอภาพ หาก
ตอ งการแสดงขอ ความใด ๆ ออกทางจอภาพใหเขียนขอความนั้นอยูภายในเครื่องหมาย “ “

• คาํ สงั่ ในภาษาซีจะตองปดทา ยดวยเครื่องหมาย ; (Semicolon) เนอื่ งจากภาษาซีจะใชเครื่อง
หมาย ; ในการแยกคาํ สั่งตาง ๆ ออกจากกัน การเวนบรรทัดหรือการเขียนคาํ สั่งไมตอเนื่องกันจะ
ไมม ผี ลตอคอมไพเลอร แตเปนการชวยใหผูเขียนโปรแกรมอานโปรแกรมไดงายขึ้นเทานั้น

จากตวั อยา งท่ี 1.1 อาจจะเขียนโปรแกรมในลักษณะตาง ๆ ซึ่งไมมีผลตอการทํางานของคอมไพเลอรดังตัวอยาง
ท่ี 1.2 และ 1.3

ตวั อยางที่ 1.2 แสดงตวั อยางโปรแกรมภาษาซีเบื้องตน

#include <stdio.h> void main( ) { /* Display message to standard output */ printf
(“My first program.”); }

ตวั อยางที่ 1.3 แสดงตวั อยางโปรแกรมภาษาซีเบื้องตน

#include
<stdio.h>
void
main
(
)
{
/* Display message
to standard
output */
printf
(
“My first program.”
)
;
}

ไมว า ผใู ชจ ะเขียนโปรแกรมในลักษณะที่ 1.1 1.2 หรอื 1.3 คอมไพเลอรจะทํางานไดผ ลลพั ธเ ดยี วกนั
เสมอ เพราะฉะน้ันการเขยี นโปรแกรมท่ีเปน ระเบยี บจะชว ยใหผเู ขียนโปรแกรมหรอื ผูอน่ื ทม่ี าอา นโปรแกรมอาน
ไดง ายขึ้น โดยทั่วไปมักใชระบบของการเยื้อง (Indentation) เขา มาชวยใหโปรแกรมอานไดงายขึ้น พจิ ารณา

5

จากตัวอยางที่ 1.2 และ 1.3 ซึ่งไมมีการเยื้องกับตัวอยางที่ 1.1 ทเี่ ขยี นโดยมีลักษณะของการเยื้อง การเยื้องนั้น
อาจจะใชการเคาะชองวาง (Space Bar) เปน จาํ นวน 3-5 ทีเพื่อใหเกิดการเยื้อง

นอกจากนหี้ ากผใู ชตองการใสคาํ อธบิ ายลงในโปรแกรม ก็สามารถทําไดโดยใชสิ่งที่เรียกวา Comment
ขอบเขตของ Comment จะขึ้นตนตั้งแต /* จนกระทั่งถึง */ ขอ ความใด ๆ ที่อยูในขอบเขตของเครื่องหมายดัง
กลา วจะไมถูกแปลโดยคอมไพเลอร โดยทั่วไปจะมีการใช Comment เพอื่ อธิบายวาโปรแกรมนั้นทาํ งานอะไร
ใชอ ธบิ ายคาํ สงั่ แตละคําสงั่ ใชอธิบายฟงกชันแตละฟงกชัน และใชอธิบายกลุมของคําสัง่ โดยเขียน
Comment ไวด า นบนหรือดานขางของสิ่งที่ตองการอธิบาย เชน หากเปนการอธิบายโปรแกรมจะเขียน
Comment ไวท ต่ี นของโปรแกรมนน้ั หากเขียนอธิบายฟงกชันจะเขียน Comment ไวดานบนของฟงกชันที่
ตอ งการอธบิ าย เขียนอธิบายคาํ สั่งอาจจะเขียน Comment ไวด า นบนหรอื ดา นขา งของคาํ สั่งนั้น ๆ และเขียน
อธบิ ายกลมุ คําสั่งก็จะเขียนอธิบายไวดานของกลุมคาํ สั่งนั้น

3. ตัวแปร

ในการเขยี นโปรแกรมคอมพิวเตอรกระบวนการสาํ คัญที่เกิดขึ้น คือ การรับขอมูล การประมวลผล
ขอ มลู และการแสดงผลขอ มลู จะเห็นวาสิ่งที่เปนสวนสําคัญที่สุดคือขอมูล การทาํ งานของโปรแกรมขณะใด
ขณะหนงึ่ จะตอ งมีการเก็บขอมูลไวในคอมพิวเตอร โดยรับขอมูลจากอุปกรณรับขอมูลไปเก็บไวในสว นที่เรียกวา
หนว ยความจาํ และสงขอมูลจากหนวยความจาํ ไปประมวลผลในหนว ยประมวลผลกลาง โดยผานคาํ สั่งตาง ๆ
เมอื่ ประมวลผลเสร็จแลวก็นําผลลพั ธท ไ่ี ดกลบั มาเกบ็ ไวท ห่ี นว ยความจําอีก เมื่อตองการใหแสดงผลก็จะใชคํา
สงั่ ใหไ ปอานขอมูลจากหนว ยความจาํ สง ขอ มลู นน้ั ไปยงั อปุ กรณแ สดงผล

พจิ ารณาจากตวั อยางการบวกเลข แสดงดังรูปที่ 1.2 โดยใหรับคาจาํ นวนเต็ม 2 คาจากผูใช และนาํ
ไปเกบ็ อยใู นหนว ยความจาํ ตาํ แหนง ท่ี 0 มีคา 15 ตําแหนง ท่ี 1 มีคา 30 หากตองการบวกนําคาทั้ง 2 มาบวกกัน
และเกบ็ ไวท ต่ี าํ แหนง ท่ี 2 จะตองใชคําสั่งในการบวก สมมติดังตัวอยาง Add 0 , 1 , 2 คอื การเอาคา ณ
ตาํ แหนง ท่ี 0 และ 1 มาบวกกนั และนาํ ไปเก็บที่ตาํ แหนง ท่ี 2 จะไดวามีการอานคา 15 จากตําแหนง ท่ี 0 ไป
บวกกบั คา 20 จากตําแหนง ท่ี 1 ไดผ ลลพั ธค อื 45 นาํ ไปเก็บในตําแหนง ท่ี 2

รปู ท่ี 1.2 แสดงแบบจาํ ลองการบวกเลขในคอมพิวเตอร

6

ในความเปน จรงิ ตาํ แหนงตาง ๆ ไมไดอางดวยเลข 0 1 หรอื 2 แตอางดวยระบบการอางที่อยูซึ่งเปน

ซบั ซอ นกวา นน้ั การเขียนในลักษณะที่เหน็ ในตัวอยางเปน การเขียนในภาษาคอมพิวเตอรย ุคแรก เชน

แอสเซมบลี (Assembly) เพอ่ื ความสะดวกในการอา งถงึ ขอ มลู ณ ตําแหนงตาง ๆ ในหนวยความจาํ จึงไดมีการ

พฒั นากนั ตอมา จนกระทั่งเปนการอางในระบบของชื่อตัวแปร (Variable) ทใ่ี ชใ นปจ จบุ นั พิจารณาจากตัว

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

ความจาํ ใหโ ดยอตั โนมัติ ผูใชไมจําเปนตองรูวาตัวแปรนั้นอยูที่ตาํ แหนงใด การอางถึงชื่อตัวแปรคือการอางถึง

ขอ มลู ในหนวยความจาํ เพราะฉะนั้นหากผูใชสรางตัวแปร a และ b เพอื่ เก็บขอมูล 15 และ 20 ตามลําดับ เมื่อ

ตอ งการหาผลบวกและนาํ คาไปเก็บไวที่หนึ่ง ก็สรางตัวแปรขึ้นมาเพื่อเก็บผลลัพธสมมติชื่อวา c การสั่งให

ทาํ งานก็สามารถทาํ ไดโดยใชคาํ ส่งั c = a + b ซงึ่ อา นไดเขาใจไดงายกวาคาํ สัง่ add 0, 1, 2

รปู ท่ี 1.3 แสดงแบบจาํ ลองการบวกเลขโดยอางชื่อตัวแปร

4. ชนิดขอมูล

ในการใชง านตวั แปรนน้ั สง่ิ สําคัญที่จะตองคาํ นึงถึงคือขอมูลที่เก็บอยูภายในตัวแปรนั้น ขอ มลู แตล ะ
ชนดิ มคี ณุ สมบตั แิ ตกตางกันไป เชน เปนเลขจาํ นวนเต็ม เปนเลขจาํ นวนจริง เปนตัวอักษร เปนตน ผูเขียน
โปรแกรมจะตอ งกําหนดชนิดขอมูลใหกับตัวแปรโดยสอดคลองกับขอมูลที่ตองการเก็บ ภาษาซีแบงขอมูลออก
เปน ชนดิ ตา ง ๆ ซึ่งมีขนาดพื้นที่ที่ตองใชเก็บขอมูลในหนวยความจาํ แตกตางกันขึ้นอยูกับชนิดขอมูลและบริษัทผู
ผลติ คอมไพเลอร ซึ่งสามารถดูรายละเอียดไดจากอินคลูชไฟล limits.h และ float.h แสดงดังตาราง 1.1

ตาราง 1.1 แสดงคุณสมบัติของชนิดขอมูลพื้นฐาน

ชนิดขอมูล ขนาด (ไบต) คาที่เก็บ
char
int 1 ตวั อกั ษร ASCII 1 ตวั ตั้งแต 0 ถึง 255
short
long 2 คา จาํ นวนเตม็ ตง้ั แต 32767 ถึง –32768
unsigned
2 คา จาํ นวนเตม็ ตง้ั แต 32767 ถึง –32768

4 คา จาํ นวนเต็มตั้งแต 2147483647 ถงึ –2147483648

unsigned int 2 คา จาํ นวนเต็มตั้งแต 0 ถึง 65535

unsigned short 2 คา จาํ นวนเต็มตั้งแต 0 ถึง 65535

unsigned long 4 คา จาํ นวนเตม็ ตง้ั แต 0 ถึง 4294967295

7

ตาราง 1.1 (ตอ ) แสดงคุณสมบัติของชนิดขอมูลพื้นฐาน

ชนิดขอมูล ขนาด (ไบต) คาที่เก็บ
float
4 คา จาํ นวนจริงตั้งแต 3.4x10-38 ถงึ 3.4x1038
double
8 คา จาํ นวนจริงตั้งแต 1.7x10-308 ถึง 1.7x10308

จากชนดิ ของขอ มลู ดังกลาว เมื่อนํามาจัดเปนประเภทขอมูลเราสามารถแบงชนดิ ของขอมูลในภาษาซี
ออกเปน ประเภทหลกั ได 3 ชนิด คือ

1. จาํ นวนเต็ม ไดแ กข อ มลู ชนดิ int, short, long, unsigned int, unsigned short และ unsigned
long

2. จาํ นวนจริง คอื ขอ มูลที่เปนเลขจาํ นวนจริง มีทศนิยม หรืออยูในรูปของนิพจนวิทยาศาสตร ได
แกข อ มลู ชนิด float และ double

3. ตวั อักขระและสตริง (String) ไดแกขอ มลู ชนดิ char ซงึ่ เก็บขอมูลได 1 อกั ขระ และขอ มลู ทเ่ี ปน
ชดุ ของขอมูล char (Array of char) ทใี่ ชเ กบ็ สตริงซึ่งจะกลาวถึงตอไป

• รปู แบบการเขียนคาตาง ๆ ทเ่ี ปน ไปไดข องขอ มลู แตล ะชนดิ ไดแ ก
- จาํ นวนเต็ม กรณเี ขยี นเปน เลขฐาน 10 เชน 125 0 -154

กรณเี ขยี นเปน เลขฐาน 8 ใหขึ้นตนดวย 0 เชน 0377 0177 0000 01
กรณเี ขียนเปนเลขฐาน 16 ใหขึ้นตนดวย 0x หรอื 0X เชน 0XFF 0x14 0x4B
กรณขี อ มลู เปน ชนดิ long ใหลงทายดวย l หรอื L เชน 123L 0437l 0x4FFL
- จาํ นวนจริง เขยี นรปู แบบทศนยิ ม เชน 12.524 0.1259 0.00001
เขยี นรปู แบบนพิ จนว ทิ ยาศาสตร เชน 1.0E4 12.432e-4 1E-4 2E+3
กรณขี อ มลู เปน float เชน 1.4321F 472.324f
กรณขี อ มลู เปน double เชน 232.98D 1.2323d
- ตวั อักขระ เชน ‘a’ ‘W’ ‘\a’ ‘\t’ โดยที่อักขระใดขึ้นตนดวย \
แสดงวาเปนอักขระพิเศษ เชน ‘\a’ แทนการสง เสยี ง

‘\t’ แทนการยอ หนา
‘\n’ แทนการขน้ึ บรรทดั ใหม
‘\0’ แทนคา NULL ซงึ่ หมายถึงคาวาง
นอกจากนยี้ งั สามารถใชในลักษณะเลขฐาน 8 และเลขฐาน 16 ไดดังนี้ ตัวอยาง
เชน ‘X’ ในตาราง ASCII ตรงกบั เลขฐาน 8 คือ 130 และเลขฐาน 16 คือ 58
เขยี นแทนคาคงที่อักขระไดคือ ‘\130’ และ ‘\x58’ ตามลําดับ
char ch1=’X’;
char ch2 = ‘\130’;
char ch3 = ‘\x58’;
ถา สั่งใหพิมพคาตัวแปร ch1 ch2 และ ch3 จะพมิ พคาเดียวกันคือ X

8

ตวั อยางที่ 1.4 แสดงตวั อยางการใชคาของตัวแปรชนิด char

#include <stdio.h>
void main( ) {

int no;
char ch;
ch = ‘J’;
printf(“char : %c, dec : %d, oct : %o, hex : %x”, ch, ch, ch, ch);
no = ch;
printf(“\nno : %d, ch : %c”, no, ch);
no = 68;
ch = no;
printf(“\nno : %d, ch : %c”, no, ch);
}

ผลการทํางานของโปรแกรม

char : J, dec : 74, oct : 112, hex : 4a
no : 74, ch : J
no : 68, ch : D

-สตรงิ จะเขียนอยูในเครื่องหมาย “ เชน “Hello” โดยทใี่ นสตริงทุกตัวจะมีอักขระพิเศษที่
ไมสามารถมองเหน็ คือ ‘\0’ หรอื NUL เปนตัวสุดทายเสมอ ในขณะทอ่ี กั ขระจะจอง
พน้ื ทห่ี นว ยความจําเพียง 1 ไบต ในตัวอยางจะไดวาเกิดการจองพื้นที่ขึ้น 6 ตัว
อกั ษร ตัวอยางการประกาศตัวแปรสตริง
char msg[ ] = “Hello”;
แสดงการจองพื้นที่ในหนวยความจาํ ใหก บั ตวั แปร msg ดังรูปท่ี 1.4

H e l l o \0

รปู ท่ี 1.4 แสดงการพื้นที่หนวยความจาํ ของตัวแปร msg

9

5. การใชตัวแปร

เมอ่ื ตอ งการใชต วั แปร จะตองมีการประกาศชื่อตัวแปรที่ตองการใชงานนั้น มรี ปู แบบคอื

ประเภทขอมูล ช่อื ตัวแปร ;

ตวั อยา งของการประกาศตัวแปร เชน
float score;
int age;
char ch;
float width, height, length;

กรณที มี่ ตี วั แปรมากกวา 1 ตัวที่มีชนิดเดียวกัน สามารถประกาศไวใ นคําสั่งเดียวกันไดโดยใชเครื่อง
หมาย , คนั่ ระหวางตัวแปรแตละตัว

กฎการตั้งชื่อ
ในภาษาซมี กี ารกาํ หนดกฎในการตั้งชื่อ Identifier ตาง ๆ อนั ไดแ ก ชอื่ ตัวแปร ชอื่ ฟงกชัน ชื่อคาคงที่

ดังนี้

• ใหใชตัวอักษร a ถงึ z A ถึง Z เลข 0 ถึง 9 และ _ (Underscore) ประกอบกันเปน
ชื่อ

• ขนึ้ ตนดวยตัวอักษรหรือ _

• ตวั อกั ษรตวั พมิ พใ หญ ตัวพิมพเล็กมีผลตอการตั้งชื่อและการเรียกใชงาน

• ชอ่ื นนั้ จะตอ งไมซา้ํ กับคําหลกั (Keyword) ซงึ่ ภาษาซีจองไวใช คือ

auto double int struct

break else long switch

case enum register typedef

char extern return union

const float short unsigned

continue for signed void

default goto sizeof volatile

do if static while

10

คาํ แนะนาํ ในการตั้งชื่อ
ในการเขยี นโปรแกรมทด่ี นี น้ั เราควรทําการตั้งชื่อของตัวแปร คาคงที่ ฟงกชัน ใหอยูในรูปแบบมาตร
ฐานดงั น้ี

• ใหต งั้ ชอื่ ทสี่ ื่อความหมายบอกใหรูวาตัวแปรนั้นใชทําอะไร
• ขนึ้ ตนดวยตัวอักษร
• กรณตี งั้ ชอื่ ตวั แปรมักจะหรือฟงกชันมักจะใชตัวอักษรตัวพิมพเล็ก
• คา คงที่ที่กาํ หนดโดย #define มกั จะใชต ัวอักษรตัวพิมพใหญทั้งหมด
• กรณที ช่ี อื่ ตวั แปรประกอบดวยคาํ หลาย ๆ คํา อาจจะใชตัวอักษรตัวพิมพใหญขึ้นตนคาํ ในลาํ ดับ

ตอ มา หรือใช _ แยกระหวางคาํ เชน totalScore หรอื total_score

ตวั อยางการตั้งชื่อตัวแปร เชน
totalscore = score1 + score2 + score3;

ยอ มจะทาํ ความเขาใจไดงายกวา
robert = willy + bird + smith;

ตวั อยางชื่อตัวแปรที่ใชได ไดแ ก _MAX MONEY Average_score
salary totalPage recordno annual2001
x

ตวั อยา งของการใชค าํ สั่งประกาศตัวแปรไมถูกตองและไมเหมาะสมไดแก

float $dollar; ใชเคร่ืองหมาย $ ในชอ่ื ตวั แปรไมไ ด

int my age; ชอื่ ตวั แปรหามเวนวรรค

integer age; ประเภทขอ มลู integer ไมมีในภาษาซี

int a. b. c; ใชเคร่อื งหมาย . แทนที่จะใชเครื่องหมาย ,

char ch: ใชเ คร่ืองหมาย : แทนที่จะใชเครื่องหมาย ;

float student-height; ใชเครอ่ื งหมาย - แทนที่จะใชเครื่องหมาย _

float 1Score; ชอื่ ตวั แปรหามขึ้นตนดวยตัวเลข

float score;

int score; หา มประกาศชื่อซํา้ กัน

11

เมอ่ื มกี ารประกาศตวั แปร จะเกิดกระบวนการจองพื้นที่ในหนวยความจาํ ใหกับตัวแปรตัวนั้นมีขนาด
เทา กบั ชนดิ ของขอ มลู ที่กาํ หนด เมื่อใดที่มีการอางถึงชื่อตัวแปรก็จะเปนการอางถึงคาที่เก็บอยูในพื้นที่หนวย
ความจาํ นน้ั สงิ่ ทตี่ องระวังคือ ควรจะมีการกาํ หนดคาเริ่มตนใหกับตัวแปรนั้น ๆ เสมอ เพราะพน้ื ทใ่ี นหนว ยความ
จาํ ทถี่ กู จองนนั้ อาจจะมีคาบางอยางอยูภายใน ตัวอยางของการกาํ หนดคาเริ่มตนใหกับตัวแปร คือ

int sum=0;
float height=0.0f;
จากคาํ สง่ั ขา งตน ระบบจะทาํ การจองพื้นที่ในหนวยความจาํ ใหกับตัวแปรชื่อ sum มขี นาดเทากับ int (2
ไบต) และกาํ หนดใหมีคาเริ่มตนเทากับ 0 เมื่อมีการอางถึงชื่อตัวแปรก็จะไดคาคือ 0 และจองพน้ื ทใ่ี นหนว ย
ความจาํ ใหก บั ตวั แปร height มขี นาดเทา กบั float (4 ไบต) และกาํ หนดใหมีคาเริ่มตนเทากับ 0.0

6. การรบั ขอ มลู และแสดงผลขอ มลู

ภาษาซีไดเตรียมฟงกชันมาตรฐานท่ีใชในการรับและแสดงผลขอมูลใหกับผูพัฒนาโปรแกรมหลาย
ฟง กช นั แตในที่นี้จะกลาวถึงเฉพาะฟงกชันในการรับขอมูล คือ ฟงกชัน scanf( ) และฟง กช นั ในการแสดงผล
ขอ มูลคือฟงกชัน print( ) ในสว นของการใชง านพน้ื ฐาน ซึ่งกอนจะใชงานฟงกชันดังกลาวที่สวนหัวของ
โปรแกรมจะตองมีคําสง่ั

#include <stdio.h>

6.1 การรบั ขอ มลู

ฟง กช นั ที่ใชในการรับขอมูลมีรูปแบบของการใชงานคือ

scanf ( รปู แบบ , อารก ิวเมนต1, อารกิวเมนต2 , … ) ;

ในการรับขอมูลผูเขียนโปรแกรมจะตองกาํ หนดรปู แบบของขอ มูลที่ตองการรับซึ่งสอดคลองกับชนิดของ
ขอ มลู ที่ตองการรับเขา โดยที่ผูใชตองสงตาํ แหนง (หรอื แอดเดรสในหนวยความจํา – Address) ของตัวแปรที่
ตอ งการรับเขาไปยังฟงกชัน โดยระบุในตาํ แหนงของอารกิวเมนต

ตวั อยา งเชน ตองการรับขอมูลเดือนและปเปนจาํ นวนเต็ม จะตองใชคําส่งั
int month, year;
scanf(“%d %d”, &month, &year);

12

จากตัวอยางรูปแบบ คือ “%d %d” บอกใหร วู าตองรับขอมูล 2 ตัว โดยที่ขอมูลนั้นแยกจากกันดวย
ชองวาง %d ตวั แรกแทนขอ มลู ตวั แรกทป่ี อ นเขา สรู ะบบจะนําไปเก็บที่ตัวแปร month %d ตัวที่ 2 แทนขอ มลู
ตวั ที่ 2 ทป่ี อ นเขา สรู ะบบจะถกู นําไปเก็บที่ตัวแปร year ในทน่ี จ้ี ะระบตุ ําแหนงของตัวแปรในหนวยความจาํ ดวย
เครื่องหมาย & (Address Operator)

รปู แบบของการรบั ขอมูลในภาษาซี จะขึ้นตนดวยสัญลักษณ % อยใู นเครื่องหมาย “ “ รปู แบบการรบั
ขอ มูลแสดงไดดังตาราง 1.2

รปู แบบ ตาราง 1.2 แสดงรปู แบบของการรบั ขอ มลู
d, i คาํ อธบิ ายการใชง าน
ld
u รบั ขอ มลู จํานวนเต็มและแปลงขอมูลเปน int
o รบั ขอ มลู จํานวนเต็มและแปลงขอมูลเปน long
x รบั ขอ มลู เปน จํานวนเต็มบวกและแปลงขอมูลเปน unsigned
c รบั ขอ มลู เปน จาํ นวนเต็มบวกของเลขฐาน 8 และแปลงขอ มลู เปน unsigned
s รบั ขอ มลู เปน จาํ นวนเต็มบวกของเลขฐาน 16 และแปลขอ มลู เปน unsigned
f รบั ขอ มลู เปน อกั ขระ 1 ตัว
lf รบั ขอ มลู เปน สตรงิ
รบั ขอ มูลทศนิยมและแปลงขอ มลู เปน float
รบั ขอ มลู ทศนยิ มและแปลงขอมลู เปน double

ตวั อยางการรับขอมูลมีดังนี้
scanf(%d/%d/%d”, &day, &month, &year);

ขอ มลู ทจ่ี ะปอ นเขา สรู ะบบ
20/7/2001

นอกจากนี้ยังสามารถกําหนดขนาดของขอมูล เชน
scanf(%2d%2d%4d”, &day, &month, &year);

ขอ มลู ทจ่ี ะปอ นเขา สรู ะบบคอื
20072001

หมายเหตุ

ใน Turbo C กรณที ม่ี กี ารรบั ขอ มลู ชนดิ char ในโปรแกรม หากในโปรแกรมมกี ารรบั ชนดิ ขอ
มลู อนื่ ดวย จะพบวาเมื่อปอนขอมูลชนิด char เสรจ็ จะไมมีการหยุดรับขอมูลในลาํ ดับถัด
ไป เนอื่ งจากความผดิ พลาดของการทํางานของคอมไพเลอร เพราะฉะนั้นควรจะใชฟงกชัน
flushall( ) ซงึ่ เปนฟงกชันมาตรฐานใน stdio.h ชว ยเพอ่ื แกป ญ หาดงั กลา ว โดยใสฟงกชัน
flushall( ) ไวหลงั คาํ สง่ั scanf( ) ทุกคาํ ส่งั

13

6.2 การแสดงผลขอ มลู
การแสดงผลขอ มลู สามารถทาํ ไดโดยการเรียกใชฟงกชัน printf( ) มรี ปู แบบคอื

printf ( รปู แบบ , อารกิวเมนต1 , อารกิวเมนต2 , … ) ;

ผเู ขยี นโปรแกรมสามารถสงขอความใด ๆ มายังฟงกชัน print( ) หรอื สงตัวแปรมาพิมพคาโดยสงผาน
มาทางอารก วิ เมนต ใหส อดคลอ งกบั รปู แบบทก่ี าํ หนด ตัวอยางเชน

char name[ ] = “Mickey”;
int age = 20;
printf(“%s is %d years old.”, name, age);

ผลลพั ธท ไ่ี ดคอื
Mickey is 20 years old.

โดยที่ %s ตวั แรกจะถูกแทนที่ดวยคาของอารกิวเมนตตัวที่ 1 คือ ตวั แปร name และ %d ตวั ที่ 2 จะ
ถกู แทนที่ดวยคาของอารก วิ เมนตตัวที่ 2 คือ ตัวแปร age

นอกจากนี้ผูใชยังสามารถใช printf( ) ในการพมิ พขอความใด ๆ ออกทางจอภาพโดยไมจาํ เปน ตอ งสง
อารก วิ เมนตเขาไปยังฟงกชันก็ได ตัวอยางเชน

printf(“Good morning.”);

ผลลพั ธท ไ่ี ดค ือ
Good morning.

ตวั อยา งของการแทนที่ตัวแปรที่เกิดจากการคาํ นวณ เชน
int x, y;
x = 7;
y = 2;
printf(“The sum of %d and %d is %d\n”, x, y, x+y);

ผลลพั ธท ไ่ี ดค อื
The sum of 7 and 2 is 9

14

คาํ สั่ง \n เปน อกั ขระพิเศษที่ไดกลาวถึงแลวคือ อักขระที่ใชสั่งใหมีการเวนบรรทัด (New Line) ในทน่ี ้ี
หลงั จากพิมพขอความเสร็จจะมีการเวนวรรทัดเกิดเขนึ้ จากตัวอยางจะเห็นวา %d ตวั ที่ 3 เกิดจากการนาํ คาของ
ตัวแปร x มาบวกกบั ตวั แปร y ไดผ ลลพั ธเ ทา ใดจงึ สง ใหก ับ %d ตวั ที่ 3 แสดงผล

รปู แบบการแสดงผล ในฟงกชัน printf( ) แสดงดังตาราง 1.3

รปู แบบ ตาราง 1.3 แสดงรปู แบบของการแสดงขอมลู
d, i คาํ อธบิ ายการใชง าน
ld
u ขอ มูลจํานวนเต็มและแปลงขอมูลเปน int
o ขอ มลู จํานวนเต็มและแปลงขอมูลเปน long
x, X ขอ มลู เปนจาํ นวนเต็มบวกและแปลงขอมูลเปน unsigned
c ขอ มลู เปนจาํ นวนเต็มบวกของเลขฐาน 8 และแปลงขอ มลู เปน unsigned
s ขอ มลู เปนจาํ นวนเต็มบวกของเลขฐาน 16 และแปลขอ มลู เปน unsigned
f ขอ มลู เปน อกั ขระ 1 ตัว
lf ขอ มลู เปน สตรงิ
ขอ มลู ทศนยิ มและแปลงขอ มลู เปน float
ขอ มลู ทศนยิ มและแปลงขอ มลู เปน double

การจดั รปู แบบการแสดงผล
กรณขี องการใชรูปแบบในฟงกชัน printf( ) จะแตกตางกับฟงกชัน scanf( ) ตรงที่ฟงกชัน printf( ) ใชใ น
การแสดงผลออกทางหนา จอ เพราะฉะนั้นจึงมีการกาํ หนดคา เพอ่ื ใหส ามารถจดั ผลลพั ธใ หแ สดงในรปู แบบท่ี
ตอ งการได โดยปกติแลวขอมูลทุกตัวที่แสดงจะแสดงผลจากทางดานขวามือ เชน

printf(“The sum of %5d and %5d is %5s\n”, a, b, a+b);
ผลลพั ธท ไ่ี ดคอื

The sum of 7 and 2 is 9.
จะเกดิ การเวน ชอ งวา ง 5 ชอง และแสดงผลจากทางดานขวามือของชองวางนั้น

ตวั อยางอื่นไดแก
float x=43.34, y=2.231;
printf(“Minus %f with %f, answer is %f”, x, y, x-y);

ผลลพั ธท ไ่ี ดค อื
Minus 43.340000 with 2.231000, answer is 41.109000

แตหากกาํ หนดวา
printf(“Minus %4.2f with %4.2f, answer is %4.2f”);

15

ผลลพั ธท ไ่ี ดค ือ
Minus 43.34 with 2.23, answer is 41.11

การจดั รปู แบบเมอ่ื ใชส ญั ลกั ษณ – ประกอบในรปู แบบจะทาํ ใหเกิดการบังคับใหการแสดงผลชิดทาง
ดา นซายมือ แสดงดังตัวอยางที่ 1.5

ตวั อยา งที่ 1.5 แสดงตวั อยางการจัดรูปแบบของการแสดงผล

#include <stdio.h> /* [Computer] */
#include <conio.h> /* [Computer] */
void main( ) { /* [Com] */
/* [ Computer] */
clrscr( ); /* [Computer ] */
printf("\n[%s]", "Computer"); /* [Com ] */
printf("\n[%2s]", "Computer");
printf("\n[%.3s]", "Computer"); /* Hexa [f] */
printf("\n[%10s]", "Computer"); /* Octal [17] */
printf("\n[%-10s]", "Computer");
printf("\n[%-10.3s]", "Computer"); /* [100] */
printf("\n"); /* [100] */
printf("\n[%x]", 15); /* [ 100] */
printf("\n[%o]", 15); /* [100 ] */
/* [100 ] */
printf("\n");
printf("\n[%d]", 100); /* [32.576200] */
printf("\n[%.2d]", 100); /* [32.58] */
printf("\n[%10d]", 100); /* [ 32.58] */
printf("\n[%-10d]", 100); /* [32.58 ] */
printf("\n[%-10.2d]", 100);

printf("\n");
printf("\n[%f]", 32.5762);
printf("\n[%.2f]", 32.5762);
printf("\n[%10.2f]", 32.5762);
printf("\n[%-10.2f]", 32.5762);
getch( );
}

ในตวั อยา งนม้ี กี ารใชฟ ง กชันเพม่ิ เตมิ เพอ่ื ชวยใหเ หน็ ผลลพั ธข องการแสดงผลทจ่ี อภาพ ) ในกรณที ผ่ี ู
เขยี นโปรแกรมใชค อมไพเลอร Turbo C คือ

16

• clrscr( ) ใชเ พอื่ ใหล บขอความตาง ๆ ทค่ี า งบนจอภาพกอ นทจ่ี ะแสดงผลโปรแกรม
• getch( ) ใชเ พอ่ื รอรบั การกดแปน พมิ พใ ด ๆ หลงั จากแสดงผลแลว เพื่อใหเกิดการคางรอใหผูใช

กดปอ นพมิ พก อ นจะไปทํางานอื่นตอไป

ทง้ั 2 ฟงกชันอยูในฟงกชันมาตรฐานของคอมไพลเลอร Turbo C ตองเรียกใชอินคลูชไฟลชื่อ conio.h
ตวั อยางที่ 1.6 เปน ตวั อยางของการรับขอมูลเขาเพื่อแสดงผลทางจอภาพ

ตวั อยางที่ 1.6 แสดงตวั อยางการรับขอมูลเพื่อนํามาแสดงผล

#include <stdio.h>

void main( ) {
char name[100];

printf("What is your name ?\n");
scanf("%s", name);
printf("Very glad to know you, ");
printf("%s.",name);
}

ผลลัพธของการทํางาน

What is your name ?
Willy
Very glad to know you, Willy.

หมายเหตุ ตวั เอยี งคอื ขอความที่ผใู ชป อ นเขาสูร ะบบ

ขอควรระวัง
- การปอ นขอ มลู ทเ่ี ปน สตรงิ ไมจ าํ เปนตองใสเครื่องหมาย & นาํ หนาตัวแปรสตริง
- หากชอื่ ทปี่ อ นเขาสูโปรแกรมมีชองวาง เชนผูใชปอนชื่อและนามสกุล โดยมีชองวางระหวางชื่อและ
นามสกลุ โปรแกรมจะรบั ไดเ ฉพาะขอ มลู ชอ่ื เทา นน้ั โปรแกรมไมสามารถรับขอมูล ที่มีชองวางเขา
มาเก็บในตัวแปรได

17

แบบฝกหัดบทที่ 1

1. ใหห าทผี่ ิดพลาดของการประกาศตัวแปรตอไปนี้ และแกไขใหถูกตอง

int $dollar, num1-5, birth year; .

char x, y, x; .

float main, double; .

integer number; .

real float; .

int a1, a2 .

int อาย,ุ ปเกิด; .

2. ใหห าทผ่ี ดิ พลาดของโปรแกรมตอ ไปน้ี และแกไขใหถูกตอง

void mian {

float a 1;

printf("Enter number : ’);

scanf("%s", a 1)

printf(“Your number is %.2d” a 1);

3. ใหจ ดั รปู แบบการเยอ้ื ง (Indentation) ของโปรแกรมตอ ไปนใ้ี หส มบรู ณ

(ก) #include <stdio.h> (ข) #include <stdio.h>

void main( ) { void main( ) { char name[100];

char name[100]; printf("What is your name ?\n"); scanf("%s", name);

printf("What is your name ?\n"); printf("Very glad to know you, "); printf("%s.",name);}

scanf("%s", name);

printf("Very glad to know you, ");

printf("%s.",name);

}

4. ใหแ สดงผลลพั ธข องการทํางานโปรแกรมตอไปนี้

(ก) # include <stdio.h> (ข) #include <stdio.h>

void main( ) { void main() {

char newline = '\n', tab = '\t'; int n=10;

float number=94.323;

printf("Start Program"); char name[15]="Mickey Mouse";

printf("%c",newline);

printf("%cMy first Program",tab); printf("\nDear %13.11s\n", "Dad and Mama");

printf("\n\tWonderful"); printf("\tI will get %x for this course!", n);

printf(" 100%%\n"); printf("\n\t%1.1f is my score", number);

printf("\t"); printf("\t\t\nLove you %d %%", n*10);

printf("%10","Hello"); printf("\n%-8.6s -Ja", name);

}}

18

5. ใหป ระกาศตัวแปรเพื่อใชเก็บขอมูลตาง ๆ ตอ ไปน้ี

(ก) เลขจาํ นวนเตม็ 5 จํานวน เก็บคาตัวเลขไมเกิน 100,000

(ข) ความสงู มีหนวยเปนเซนติเมตร

(ค) นามสกลุ ความยาวไมเกิน 30 ตัวอักษร

(ง) เลขทบ่ี ตั รประจําตวั ประชาชนเปน ตวั เลข 13 หลกั

(จ) จาํ นวนพนกั งานในบรษิ ทั แหง หนง่ึ มีพนักงานไมเกิน 500 คน

(ฉ) คะแนนสอบของนกั ศกึ ษาในกระบวนวชิ าหนง่ึ มีคาไมเกิน 100 คะแนน

(ช) เงนิ เดือนท่พี นกั งานบรษิ ทั แหง หน่งึ ไดร บั

6. ใหเ ขยี นโปรแกรมเพอ่ื รบั ขอ มลู ตา ง ๆ ในขอ 5 และแสดงผลขอ มลู ทร่ี บั นน้ั

7. ใหเขียนโปรแกรม 2 โปรแกรมเพื่อแสดงขอความตอไปนี้ออกทางจอภาพ

I love

C programming

very much.

โดยที่

(ก) เขยี นโปรแกรมท่ี 1 โดยในฟงกชัน main( ) ประกอบดวยฟงกชัน printf( ) 3 คาํ ส่ัง

(ข) เขยี นโปรแกรมท่ี 2 โดยใชฟงกชัน main( ) ประกอบดวยฟงกชัน printf( ) 1 คาํ สง่ั

8. ใหเ ขยี นโปรแกรมเพื่อรับชื่อและความสูงของคน ๆ หนง่ึ และแสดงชื่อและความสูงนั้นทางจอภาพ โดย

แสดงในรปู แบบดงั ตวั อยา งตอ ไปน้ี (ตวั เอนคอื สง่ิ ทผ่ี ใู ชป อ นสรู ะบบ)

Enter name : Somchai

Enter height (cm.) : 178

Output :

Name Height (cm.)

Somchai 178

9. ใหเ ขียนโปรแกรมรับขอมูลเลขจาํ นวนจริงแบบ float 3 จาํ นวน และแสดงผลลพั ธเ ลขทง้ั 3 จํานวนดังตัว

อยาง (ตวั เอนคอื สง่ิ ทผ่ี ใู ชป อ นสรู ะบบ)

Enter number 1 : 5243.2

Enter number 2 : 13

Enter number 3 : 12.3548

Output :

5243.20

13.00

12.35

ตวั ดําเนินการและนิพจน 2

(Operators and Expressions)

ในการเขยี นโปรแกรมองคประกอบทีส่ าํ คัญสิ่งหนึ่งคือ ตัวดาํ เนนิ การ ซึ่งมักจะนําใชรว มกบั นพิ จนใ น
ลกั ษณะตา ง ๆ ตัวดาํ เนนิ การทส่ี าํ คัญ ไดแ ก ตัวดาํ เนินการกาํ หนดคา (Assignment Operator) ตวั ดาํ เนนิ
การคณติ ศาสตร (Arithmetic Operators) ตวั ดาํ เนินการกาํ หนดคา แบบผสม (Compound Assignment
Operators) ตวั ดาํ เนินการเพิ่มคาและลดคา (Increment and Decrement Operators) ตวั ดาํ เนนิ การเปลย่ี น
ชนิดขอมูล (Type Cast Operator) ตวั ดาํ เนนิ การความสมั พันธ (Relational Operators) ตวั ดาํ เนินการความ
เทากัน (Equality Operators) ตวั ดาํ เนนิ การตรรกะ (Logical Operators) ตวั ดาํ เนนิ การเงอ่ื นไข (Conditional
Operator) ตวั ดาํ เนินการคอมมา (Comma Operator)

ตวั ดาํ เนนิ การเหลา นเ้ี มอ่ื นําไปใชก บั นพิ จนจ ะทําใหเ กดิ นพิ จนใ นรปู แบบตา ง ๆ เชน นิพจนกาํ หนดคา
นพิ จนคณิตศาสตร นพิ จนต รรกศาสตร เปนตน

1. ตวั ดาํ เนินการกําหนดคา

ตวั ดาํ เนนิ การกาํ หนดคา เปน ตวั ดาํ เนินการพื้นฐานที่ใชในการกาํ หนดคาตาง ๆ ใหกับตัวแปร โดยใช
เครื่องหมาย = มรี ปู แบบของนพิ จนก าํ หนดคาคือ

ตัวแปร = นพิ จน ;

โดยทน่ี พิ จนอ าจจะเปน คา คงท่ี ตัวแปร หรอื นพิ จนท ป่ี ระกอบขน้ึ จากตวั ดาํ เนินการตาง ๆ ก็ไดตัวอยางเชน
age = 10;
speed = distance / time;
total_min = 60 * hours + minutes;
ch = ‘A’;

ความหมายของตวั ดาํ เนินการกาํ หนดคาคือ การกาํ หนดคาที่อยูทางขวามือของคาํ สั่งใหกับตัวแปรที่อยู
ทางซายมือ

นอกจากนยี้ งั มรี ปู แบบเพิ่มเติมหากตองการกําหนดคาใหกับตัวแปรหลายตัวดวยคาเดียวกัน มรี ปู แบบ
ดังนี้คือ

ตัวแปร1 = ตวั แปร2 = …. = นพิ จน ;

20

โดยตวั แปรทั้งหมดจะตองเปนตัวแปรประเภทเดียวกัน เชน
int x, y, z;
x = y = z = 45;

แปลความหมายไดวา
z = 45;
y = z;
x = y;

นอกจากนี้เมื่อมีการใชตัวดําเนินการกําหนดคาจะมีการแปลงคาชนิดของขอมูลโดยอัตโนมัติอีกดวย
(Implicit Casting) ซงึ่ จะเกดิ กับขอมูลตัวเลข เชน กาํ หนดคาที่มีชนิดเปน int ใหก บั ตวั แปรทม่ี ชี นดิ เปน float
จะเกดิ กระบวนการแปลงคาจาก int ไปเปน float เชน

float x;
x = 14;
14 เปน ขอ มลู ประเภท int แต x เปน ตวั แปรประเภท float เพราะฉะนน้ั คา 14 จะถูกแปลงเปน 14.0f
กอ นทจ่ี ะนาํ ไปเก็บยังตัวแปร x แตห ากมกี ารกาํ หนดคาที่มีชนิดเปนจํานวนจริงใหกับตัวแปรที่เปนจาํ นวนเต็มจะ
เกดิ การปดเศษทิ้ง ตัวอยางเชน
int a;
a = 3.5;
จะไดวามีการแปลงคา 3.5 ไปเปน 3 กอ นทจ่ี ะนาํ คานั้นไปกาํ หนดใหกับ a จะไดวา a เก็บคา 3
พจิ ารณาตัวอยางตอไปนี้
int a;
float x;
x = a = 12.74;
จะไดวามีการกาํ หนดคา a = 12.34 กอ น ซึ่งมีการแปลงคา 12.74 โดยปดเศษทิ้ง ไดวา a เกบ็ คา 12
จากนน้ั นาํ คาใน a ไปกาํ หนดคา ใหก ับตวั แปร x ซงึ่ เปน float จะมีการแปลงคา 12 เปน 12.0f จะไดวา x เก็บคา
12.0 แสดงตวั อยา งเรื่องการปดเศษดวยตัวอยางที่ 2.1

21

ตวั อยา งที่ 2.1 แสดงการกาํ หนดคาจํานวนจริงใหกับตัวแปรจาํ นวนเต็ม

#include <stdio.h>

void main( ) {
int x;
x = 14.8328;
printf(“x value is %d”, x);

}

ผลการทํางานของโปรแกรม

x value is 14

2. ตวั ดาํ เนินการคณิตศาสตร

ตวั ดาํ เนนิ การคณิตศาสตรในภาษาซีประกอบดวยการบวก ลบ คูณ หาร หารเอาเศษ การเขียน
นพิ จนค ณติ ศาสตรท างคอมพิวเตอรจะแตกตางกับนิพจนคณิตศาสตรที่เคยเรียนทั่วไป ตรงทมี่ ีลําดับความ
สาํ คัญ (Precedence) ของตวั ดาํ เนนิ การเขา มาเกย่ี วขอ ง แสดงตัวดําเนินการคณิตศาสตรและการทาํ งานดัง
ตาราง 2.1 และแสดงลําดับความสําคัญของตัวดาํ เนนิ การดังตาราง 2.2

ตาราง 2.1 แสดงตัวดําเนนิ การคณิตศาสตรและการทาํ งาน

ตวั ดาํ เนินการ คําอธิบาย ตัวอยาง การทาํ งาน ผลลพั ธ
+ +10
- Unary plus +10 ขวาไปซาย -7
* 30
/ Unary minus -7 ขวาไปซาย 3
% 1
+ Multiplication 10*3 ซายไปขวา 13
- 7
Division 10/3 ซา ยไปขวา

Modulus 10%3 ซายไปขวา

Addition 10+3 ซา ยไปขวา

Subtraction 10-3 ซายไปขวา

ตาราง 2.2 แสดงลําดับความสําคัญของตัวดาํ เนนิ การ

ตวั ดาํ เนินการ คําอธิบาย

+, - Unary Plus, Unary Minus

*, /, % Multiplication, Division, Modulus

+, - Addition, Subtraction

22

จากตาราง 2.2 ตัวดาํ เนนิ การทอ่ี ยดู า นบนจะมคี วามสําคัญกวาดานลา ง นน่ั คอื หากในนพิ จนป ระกอบ

ดว ยตวั ดาํ เนนิ การดา นบนจะมกี ารแปลคา ตวั ดําเนนิ การนน้ั การ หากพบตัวดาํ เนนิ การทอ่ี ยใู นลาํ ดับเดียวกันก็

จะทาํ การแปลความหมายจากซายไปขวา ตัวอยางเชน

3+4/2 จะไดผ ลลพั ธเ ทา กบั 3 + (4 / 2) = 5

3 * 2 + 4 % 2 จะไดผ ลลพั ธเ ทา กบั (3*2) + (4%2) = 6 + 0 = 6

แตห ากตอ งการใหทาํ ตัวดาํ เนนิ การในลําดับตํ่ากอน ใหใชเครื่องหมาย ( ) ครอบคําสั่งที่ตองการ เชน

3 * (2 + 4 )% 2 จะไดผ ลลพั ธเ ทา กบั 3 * 6 % 2 = 18 % 2 = 0

เพราะฉะนั้นหากมีสมการเชน

X = A+B+C
10

หากตอ งการเขียนเปนนิพจนคณิตศาสตร จะตองเขียนวา

X = (A + B + C) / 10

สิ่งสาํ คัญอกี สง่ิ หนง่ึ ในการใชต ัวดาํ เนินการคณิตศาสตร คือ การคาํ นวณภายในนพิ จนท่ีเกดิ จากขอ มลู

ชนดิ จาํ นวนเต็มกับขอมูลจาํ นวนจริง และการใช Modulus ตวั อยางเชน

float f;

f = 17.0 / 4; /* f = 4.25 */

f = 17 / 4.0; /* f = 4.25 */

f = 17 / 4; /* f = 4.0 */

int a; /* a = -5 */
a = -17 / 3; /* a = -5 */
a = 17 / -3; /* a = 5 */
a = -17 / -3;

a = 17 % 3; /* a = 2 */
a = 15 % 3; /* a = 0 */

a = -17 % 3; /* a = -2 */
a = 17 % -3; /* a = 2 */
a = -17 % -3; /* a = -2 */

และแสดงตวั อยา งการทาํ งานของตัวดาํ เนนิ การคณิตศาสตรดังตาราง 2.3 สมมติให a และ b มคี าเปน
จาํ นวนเตม็ และแสดงตัวอยางการหาผลรวมของเลขจาํ นวนเต็ม 2 จํานวนที่รับจากผูใช ดังตัวอยางที่ 2.2

23

ตาราง 2.3 แสดงตวั อยา งการประมวลผลตวั ดาํ เนินการคณิตศาสตร

ab a/b a%b a+b*3

17 3 5 2 26

-17 3 -5 -2 -8

17 -3 -5 2 8

-17 -3 5 -2 -26

ตวั อยางที่ 2.2 โปรแกรมหาผลรวมของเลขจาํ นวนเต็ม 2 จํานวนที่รับขอมูลจากผูใช

#include <stdio.h>
void main( ) {

int x, y, z;
printf(“Enter X value : “);
scanf(“%d”, &x);
printf(“Enter Y value : “);
scanf(“%d”, &y);
z = x + y;
printf(“Summary of X and Y is %d”, z);
}

ผลการทํางานของโปรแกรม

Enter X value : 15
Enter Y value : 20
Summary of X and Y is 35

3. ตวั ดาํ เนินการกําหนดคาแบบผสม

ตัวดําเนินการกําหนดคาแบบผสมเปนตัวดําเนินการที่ผสมระหวางตัวดําเนินการกําหนดคาและตัว
ดาํ เนนิ การคณิตศาสตร แสดงดังตาราง 2.4

ตาราง 2.4 แสดงตัวดําเนินการกาํ หนดคา แบบผสม

ตวั ดาํ เนินการ ตวั อยางคาํ สั่ง คาํ สั่งเต็ม

*= a *= 2; a = a * 2;

/= a /=2; a = a / 2;

%= a %= 2; a = a % 2;

+= a += 2; a = a + 2;

-= a -= 2; a = a – 2;

24

การแปลคาํ สงั่ ของตัวดาํ เนินการกาํ หนดคา แบบผสม จะทําคาํ สั่งที่อยูทางขวามือกอนเสมอ เชน
a *= 3 + 2 ;

จะเทากับคาํ สั่ง
a = a * (3 + 2);

4. ตวั ดาํ เนินการเพิ่มคาและลดคา

ตวั ดาํ เนนิ การเพมิ่ คาและลดคา เปนตัวดาํ เนินการเพื่อใชเพิ่มคาตัวแปรขึ้น 1 หรอื ลดคา ตวั แปรลง 1
โดยใชเครื่องหมาย ++ แทนการเพม่ิ คา ขน้ึ 1 และ - - แทนการลดคาลง 1 และสามารถใชตัวดําเนินเพม่ิ คา หรอื
ลดคา กบั ตวั แปรได 2 ตาํ แหนง คือ วางตัวดาํ เนินการเพิ่มคาหรือลดคาไวหนาตัวแปร และวางไวหลังตัวแปร ดัง
ตวั อยาง

a++;
++a;
ทง้ั 2 คาํ สั่งจะมีคาเทา กับ a = a + 1; สว นคําส่งั
a- -;
- - a;
จะมีคาเทากับ a = a – 1;

ความแตกตา งของตําแหนงการวางตัวดาํ เนินการเพิ่มคาหรือลดคา
ตาํ แหนง ของการวางตัวดาํ เนนิ การเพิ่มคาหรือลดคาจะสงผลถึงการทํางานของคาํ สั่งนั้น ตัวอยางเชน

b = 5;
a = 10 + b++ * 2;
ผลลพั ธท ไ่ี ด จะมีผลเทากับคาํ สงั่
a = 10 + b * 2;
b = b + 1;

จะไดวา a มคี า เทากับ 10 + 5 * 2 = 20 และ b มคี าเทากับ 6

แตห ากนาํ ตวั ดาํ เนนิ การเพ่มิ คามาไวดานหนาตัวแปร ดังตัวอยาง โดยกาํ หนดให b มคี า เทากับ 5 เชน
เดียวกัน

b = 5;
a = 10 + ++b * 2;

25

ผลลพั ธท ไ่ี ด จะมีผลเทากับคาํ ส่งั
b = b + 1;
a = 10 + b * 2;

จะได b มคี าเทา กับ 6 และ a มคี า เทา กับ 10 + 6 * 2 = 22

ตวั อยา งที่ 2.3 แสดงการใชตัวดาํ เนินการเพิ่มคา

#include <stdio.h>
void main( ) {

int y, count;
count = 1;
y = count++;
printf(“y = %d, count = %d”, y, count);
count = 1;
y = ++count;
printf(“\ny = %d, count = %d”, y, count);
}

ผลการทํางานของโปรแกรม

y = 1, count = 2
y = 2, count = 2

5. ตวั ดาํ เนนิ การเปลี่ยนชนิดของขอมูล

การเปลยี่ นชนิดขอมูลในภาษาซีมี 2 ลกั ษณะ คือ การเปลี่ยนชนิดขอมูลโดยไมตองใชคําสัง่ (Implicit
Casting) ซง่ึ กลา วถงึ ในหัวขอท่ี 2.1 และการเปลี่ยนชนิดขอมูลโดยใชคาํ สั่ง (Explicit Casting) เชน หากตอง
แปลงขอ มลู ชนดิ float ไปเปน อกี ขอ มลู ชนดิ int จะตองใชคาํ ส่ัง

int a;
a = (int)12.423;
จะไดวา a มคี า เทา กบั 12 กระบวนการทาํ งานจะมีการเปลี่ยนชนิดขอมูลที่อยูใกลกับตัวดําเนนิ การ
เปลย่ี นชนดิ ขอ มลู ใหเ ปน ชนดิ ขอ มลู ทร่ี ะบใุ นวงเลบ็ แลวจึงมีการกาํ หนดคาใหมนั้นใหกับ a ทงั้ นสี้ ามารถกาํ หนด
ชนดิ ขอ มลู ทจี่ ะเปลี่ยนคาเปนชนิดขอมูลใด ๆ ก็ได แสดงตัวอยางเพิ่มเติมดังตัวอยางที่ 2.4

26

ตวั อยางที่ 2.4 แสดงการใชตวั ดาํ เนินการเปลี่ยนชนดิ ขอ มลู

#include <stdio.h>
void main( ) {

int x;
x = 2.5 * 2;
printf(“x value is %d”, x);
x = (int)2.5 * 2;
printf(“\nx value is %d”, x);
x = (int)(2.5 * 2);
printf(“\nx value is %d”, x);
}

ผลการทํางานของโปรแกรม

x value is 5
x value is 4
x value is 5

6. ตวั ดาํ เนินการคอมมา

ตวั ดาํ เนนิ การคอมมา เปนตัวดาํ เนนิ การเพอ่ื บอกถึงลําดับการทาํ งาน เพื่อชวยกาํ หนดการทาํ งานของ
นพิ จนห นง่ึ ๆ มักจะใชรวมกับคําสั่งควบคุม รูปแบบการใชต วั ดาํ เนินการคอมมา คือ

นพิ จน1 , นพิ จน2

การทาํ งานจะทาํ งานที่นิพจนทางซายมือกอนเสมอ แลวจึงทาํ งานที่นิพจนขวามือ แตถาใชคาํ สัง่

s = ( t = 2, t + 3);

ลาํ ดับการทาํ งานคือ t = 2 หลงั จากนั้นจะนําคาใน t คอื 2 ไปบวกกบั 3 จะไดคาคอื อ 5 และนาํ คา 5
ไปกาํ หนดใหกับ s จะไดวา t มีคา 2 และ s มคี า 5

แตห ากไมมีเครื่องหมายวงเล็บดังตัวอยาง
s = t = 2, t + 3

จะไดวา s เทากับ 2 และ t เทา กับ 2 หลงั จากนน้ั นาํ คา t ไปบวก 3 ไดผ ลลพั ธข องนพิ จนเ ปน 5 มักจะ
ใชก บั นพิ จนต รรกศาสตรใ นคาํ สั่งควบคุมแบบตาง ๆ ซง่ี จะไดก ลา วถงึ ในบทท่ี 3

27

7. ตวั ดาํ เนินการความสัมพันธ

ตวั ดาํ เนนิ การความสมั พนั ธไดแ กต วั ดาํ เนนิ การทใ่ี ชเ ปรยี บเทยี บนพิ จน 2 นพิ จน มักใชกับคําสั่งควบคุม
ซง่ึ จะกลา วถงึ ในบทท่ี 3 ดังตาราง 2.5

ตาราง 2.5 แสดงตัวดําเนนิ การความสัมพันธ

ตวั ดาํ เนินการ ความหมาย

> มากกวา

< นอยกวา

>= มากกวาหรอื เทา กับ

<= นอ ยกวาหรือเทากับ

ผลทไี่ ดจากการใชดําเนนิ การความสัมพันธ คือ จริง (True) หรือเท็จ (False) ซงึ่ ในภาษาซีแทนดวย
เลขจาํ นวนเต็ม กรณีเท็จจะแทนดวยคา 0 และกรณจี รงิ จะแทนดวยคา ที่ไมใช 0 ทดสอบคาการเปรียบเทียบดัง
ตวั อยา งท่ี 2.5 และแสดงตวั อยางการประมวลผลนพิ จนค วามสมั พนั ธด ังตาราง 2.6

ตวั อยา งที่ 2.5 แสดงคา ของการเปรียบเทียบดวยตัวดาํ เนนิ การความสัมพันธ

#include <stdio.h>
void main( ) {

int x, y
printf(“Enter X : “);
scanf(“%d”, &x);
printf(“Enter Y : “);
scanf(“%d”, &y);
printf(“X > Y is %d”, x>y);
}

ผลการทํางานของโปรแกรม

Enter X : 32
Enter Y : 24
X > Y is 1

28

ตาราง 2.6 แสดงตวั อยา งการประมวลผลนพิ จนค วามสมั พนั ธ กาํ หนดให a = 5 และ b = 3

นพิ จน แปลงนิพจน คาตรรกะ คาที่ได

5+2*4 < (5+2)*4 5+(2*4) < (5+2)*4 True 1

a + b <= b+a (5+3) <= (3+5) True 1

a/b < b/a (5/3) < (3/5) False 0

8. ตวั ดาํ เนินการความเทากัน

ตวั ดาํ เนนิ การความเทา กนั เปน ตวั ดาํ เนินการเพื่อใชเปรียบเทียบความเทากันของนิพจน 2 นพิ จน มัก
ใชก บั คาํ สง่ั ควบคมุ ซง่ึ จะกลา วถงึ ในบทท่ี 3 มีตัวดาํ เนินการดังตาราง 2.7

ตาราง 2.7 แสดงตัวดําเนินการความเทากัน

ตวั ดาํ เนินการ ความหมาย

== เทากัน

!= ไมเทากัน

ผลลพั ธข องการเปรยี บเทยี บมีคา คือจริง หรอื เทจ็ การใชงานจะตองระวังเพราะมีความสับสนระหวาง

การใชต วั ดาํ เนนิ การความเทากัน == กบั ตวั ดาํ เนนิ กาํ หนดคา = ซงึ่ มกี ารทาํ งานที่ตางกัน และตัวดาํ เนนิ การไม

เทา กันใชเครื่องหมาย != ไมใ ชเครื่องหมาย <> เหมือนในภาษาอื่น ๆ เชน

a == 2 เปน การเปรยี บเทยี บวาตวั แปร a มคี า เทา กับ 2 หรอื ไม

a = 2 เปน การกาํ หนดคา 2 ใหกับตัวแปร a

ในการเปรียบเทียบคาจะตองระวังเร่ืองของเลขทศนิยมซึ่งเกิดจากการคํานวณของเครื่องคอมพิวเตอร

ซงึ่ คอมพวิ เตอรแ ตละเคร่อื งอาจจะใหผลการคาํ นวณที่ตางกันดังตัวอยาง

float a=1.0f;

คาํ สงั่ a == a / 3.0 * 3.0 อาจจะใหค า ถา คาดไมถ งึ เนื่องจากในทางคณิตศาสตร 1 / 3 * 3 จะได

คา เทา กบั 1 แตใ นทางคอมพวิ เตอร เครื่องคอมพิวเตอรบางเครื่องเมื่อ 1 / 3 จะไดค า 0.33333… เมอ่ื นํากลบั

มาคณู กับ 3 จะไดคา 0.99999… ซง่ึ ผลลพั ธจ ะไมเทากบั 1.0 ตามที่ผูเขียนโปรแกรมตั้งใจ แสดงตัวอยางการใช

ตวั ดาํ เนนิ การความเทากันดังตัวอยางที่ 2.6

29

ตวั อยา งที่ 2.6 แสดงคา ของการเปรียบเทียบดวยตัวดาํ เนนิ การความเทากัน

#include <stdio.h>

void main( ) {
int x, y, result;
printf(“Enter X : “);
scanf(“%d”, &x);
printf(“Enter Y : “);
scanf(“%d”, &y);
result = (x==y);
printf(“X == Y is %d”, result);

}

ผลการทํางานของโปรแกรม

Enter X : 25
Enter Y : 4
X == Y is 0

9. ตวั ดาํ เนินการตรรกะ

ตวั ดาํ เนนิ การตรรกะเปน ตวั ดําเนินการที่ใชคูกับตัวดาํ เนนิ การความสมั พันธและตัวดําเนนิ การความเทา
กนั ซง่ึ มกั จะใชก บั คาํ สั่งควบคุมซึ่งจะกลาวถึงในบทที่ 3 มีตัวดาํ เนนิ การดังตาราง 2.8 และมกี ารทาํ งานเหมือน
กบั การเปรยี บเทยี บเชงิ ตรรกะทว่ั ไป แสดงดว ยตารางคาความจริงในตาราง 2.9

ตาราง 2.8 แสดงตัวดําเนนิ การตรรกะ

ตวั ดาํ เนินการ ความหมาย

&& Logical AND

|| Logical OR

! Logical NOT

ตาราง 2.9 แสดงตารางคาความจริงของตัวดําเนนิ การตรรกะ

PQ P&&Q P||Q P !P
false
true true true true true true

true false false true false

false true false true

false false false false

30

ตวั อยางของการเปรียบเทียบไดแก 0
!10 ผลลพั ธค อื 1
!0 ผลลพั ธค อื 0
!’A’ ผลลพั ธค อื
สมมติให int a=1, b=3, c=4;
แสดงตวั อยา งการประมวลผลดงั ตาราง 2.10

ตาราง 2.10 แสดงตวั อยางการใชตัวดําเนนิ การตรรกะ

นพิ จน แปลงนิพจน คาตรรกะ คาที่ได
0
a + b > 0 && b / c > 1 ((a+b)>0) && ((b/c) > 1) False 1
0
a /c == b / c && (a+b) /c ==1 ((a/c)==(b/c))&&(((a+b)/c)==1) True

!a || !b ||!c (!a) || (!b) || (!c) False

ในการใชตัวดาํ เนินการตรรกกะสิ่งที่ตองระวังคือ Short Circuit เนอื่ งจากเราทราบวา ในกรณขี อง &&
(Logical And) หากนพิ จนแรกเปนเท็จ ไมว า นพิ จนท ่ี 2 เปน อะไร จะทําใหน พิ จนน น้ั เปนเทจ็ เสมอ และในกรณี
ของ || (Logical Or) หากนพิ จนแรกเปนจริง ไมว า นพิ จนท ่ี 2 เปน อะไร จะทําใหนพิ จนน นั้ เปนจริงเสมอ
คอมไพเลอรใ ชหลักการคิดนี้เชนเดียวกัน ทาํ ใหไ มม กี ารประมวลผลนพิ จนท ่ี 2 ในกรณที น่ี พิ จนแ รกทําใหเ กิด
Short Circuit แสดงดังตัวอยาง

int a=10;
printf(“[%d]”, a < 10 && a++ > 10);
printf(“\na is %d”, a);

จากตวั อยางผูเขียนตองการเพิ่มคา a ขนึ้ 1 หลังจากทาํ งานฟงกชัน printf( ) คาํ สง่ั แรก แตเนื่องจาก
นพิ จน a < 10 เปน เทจ็ ทาํ ใหน พิ จนห ลงั ไมถ กู ประมวลผล จึงไมเกิดการเพิ่มคา a จะได a มคี า เทากับ 10
เหมือนเดิม

พจิ ารณาตัวอยาง Short Circuit กรณขี องการใชตัวดาํ เนนิ การ ||
int a = 10;
printf(“[%d]”, a < 20 || a++ > 10);
printf(“\na is %d”, a);

จากตัวอยางนิพจน a < 20 เปน จรงิ ทาํ ใหเ กิด Short Circuit คอื ไมม กี ารประมวลผลในนพิ จนท ่ี 2
ของตวั ดาํ เนนิ การ || คา a จงึ ไมถ ูกเพิ่มคา จะไดคําตอบวา a มคี า เทากับ 10 เหมือนเดิม

31

นอกจากนี้การเขียนนิพจนตรรกศาสตรท่ีคุนเคยในชีวิตประจําวันในบางลักษณะไมสามารถทําไดใน
ทางคอมพวิ เตอร ตัวอยางเชน หากตองการทราบวา x มคี า อยใู นชวงตั้งแต 10 ถึง 20 จรงิ หรอื ไม ปกติแลว จะ
เขียนวา 10 <= x <=20 ซงึ่ รปู แบบนไี้ มสามารถใชไดในทางคอมพิวเตอร ที่ถูกตองจะตองเขียนวา

x >= 10 && x <=20

10. ตวั ดาํ เนินการเงื่อนไข

ตวั ดาํ เนนิ การเงอ่ื นไขเปน ตวั ดาํ เนนิ การทใ่ี ชต รวจสอบเงอ่ื นไขของนพิ จน มรี ปู แบบคอื
นพิ จน1 ? นพิ จน2 : นพิ จน3

การประมวลผลจะตรวจสอบนพิ จน1 วาเปน จรงิ หรอื เทจ็ หากเปนจริงจะทํางานในนพิ จน2 แตหากเปน
เทจ็ จะทาํ งานในนพิ จน3 แสดงดังตัวอยาง

min = (a < b) ? a : b;
การดาํ เนินการจะเปรียบเทียบคา a และ b หาก a มคี า นอยกวา b จรงิ จะไดวา min = a แตห าก
นพิ จน a < b เปนเท็จจะไดวา min = b; แสดงตวั อยางเพิ่มเติมในตัวอยางที่ 2.7 และ 2.8

ตวั อยา งที่ 2.7 โปรแกรมรบั ขอ มลู เลขจํานวนเต็มจากผูใช 2 จํานวน คือ x และ y หาก x มคี ามาก
กวา y ใหข ึ้นขอความวา “X more than Y” แตถ า ไมใชใหขึ้นขอความวา “X not more than Y”

#include <stdio.h>
void main( ) {

int x, y;
printf(“Enter X : “);
scanf(“%d”, &x);
printf(“Enter Y : “);
scanf(“%d”, &y);
(x > y) ? printf(“X more than Y”) : printf(“X not more than Y”);
}

ผลการทํางานของโปรแกรม

Enter X : 12
Enter Y : 8
X more than Y

32

ตวั อยางที่ 2.8 โปรแกรมรบั ขอ มลู เลขจํานวนเต็มจากผูใช 2 จํานวน คือ x และ y ใหหาวาคาที่มีคา
นอ ยที่สุดคือคาใด

#include <stdio.h>
void main( ) {

int x, y, min;
printf(“Enter X : “);
scanf(“%d”, &x);
printf(“Enter Y : “);
scanf(“%d”, &y);
min = (x < y) ? x : y;
printf(“Minimum value is %d”, min);
}

ผลการทํางานของโปรแกรม

Enter X : 12
Enter Y : 8
Minimum value is 8

33

แบบฝกหัดบทที่ 2

1. แปลงสมการตอ ไปนเ้ี ปน นพิ จนค ณติ ศาสตร .
(ก) .

x = 2y2 + y×3

(ข)

x = 2y2 + 4
2

2. หาทผ่ี ดิ ในนพิ จนต อ ไปน้ี และแกไขใหถูกตอง

(ก) a = + a – b * 3 2 .

(ข) a = ab + c .

(ค) x <> y .

(ง) a => b .

(จ) a1 > a2 OR a1 > a3 .

(ฉ) 10 <= x <= 20 .

(ช) (((a+b) > 10) && ((a-b) > 5))) .

3. ใหเขียนนิพจนตามที่โจทยระบุ

(ก) มีตัวแปร a b และ c ใหเ ขยี นนพิ จนเ พอ่ื หาคา ของ a ซงึ่ เกิดจาก b ยกกาํ ลังสองบวกกับ c

.

(ข) มีตัวแปร a b และ c ใหเ ขยี นนพิ จนเ พอ่ื หาคา ของ a ซงึ่ เกิดจาก a คณู กับ c แลวหารดวย b

.

(ค) มีตัวแปร a b และ c ใหเ ขยี นนพิ จนเ พอ่ื เปรยี บเทยี บวา a บวก b มคี า มากกวา a บวกดวย c หรอื ไม

.

(ง) มีตัวแปร a ใหเ ขยี นนพิ จนเ ปรยี บเทยี บวา a มคี า มากกวา 0 และเมื่อบวก a ดวย 5 มคี า ไมเกิน 100

.

(จ) มีตัวแปร x เกบ็ อายขุ องพนกั งานคนหนง่ึ ในบรษิ ทั ใหตรวจสอบวา x มอี ายอุ ยูในชวงตั้งแต 25 ปข น้ึ ไป

แตวาไมเกิน 60 ป

.

(ฉ) มีตัวแปร x เกบ็ จาํ นวนจริงจาํ นวนจริง ใหตรวจสอบวา x มคี า นอ ยกวา 100 หรือมากกวา 500

.

4. ใหค ําตอบของนพิ จนต อ ไปน้ี

(ก) int a=5, b=10, c=15, d;

d = a + 5 * b; /* d = . */

d = a + 5 * b; /* d = . */

d = b / a * c; /* d = . */

34

d = a + b * 3 / 2 – b / 4 + a % 2 + 10; /* d = . */

d=5

d += a + b % 3; /* d = . */

d %= b - 3; /* d = . */

d = a++ + b++ + 2; /* d = . */

/* a = . */

/* b = . */

d = ++a + a++; /* d = . */

/* a = . */

d = a + b++ 2 – b++ / 4 + ++a % 2; /* d = . */

/* a = . */

/* b = . */

(ข) int a=5, b;

float x=12.5, y;

b = 15.7; /* b = . */

y = 10; /* y = . */

b = a / 2; /* b = . */

y = x / 2; /* y = . */

b = a % 3 * 2.5; /* b = . */

y = x + 6 / 3; /* y = . */

(ค) int a=5, b=10, c=3;

a > b || a < c /* คาํ ตอบ = . */

(a + b / 3) > 10 /* คาํ ตอบ = . */

a*c > b && b*a/c < b/a*c /* คาํ ตอบ = . */

a >= 10 || b >=10 && c*a >= 10 /* คําตอบ = . */

! (a < b) && (a > c) || !(a+c > b) /* คาํ ตอบ = . */

5. เขยี นโปรแกรมคาํ นวณพื้นที่ของวงกลม โดยรับรัศมีของวงกลมจากผูใช สูตรการหาพื้นที่ของวงกลมไดแก

CircleArea = 1 PI *r2
2
กาํ หนดใหคา PI คือ 3.14159265

6. เขยี นโปรแกรมรบั ขอมูลจาํ นวนเต็ม 5 จํานวนจากผูใช และหาวาคาเฉลี่ยของขอมูลที่รับเขามามีคาเทาใด

7. เขยี นโปรแกรมใหร บั คา จาํ นวนจริงจากผูใช 1 จํานวน และใหห าวาเลขดังกลาวอยูในชวงของเลขจํานวน

เตม็ ใด เชน หากผใู ชป อ นเลข 12.5 ใหตอบวา “12.5 is between 12 and 13” (ใชต วั ดําเนนิ การเปลย่ี น

ชนดิ ขอมูลในการเขียนโปรแกรม)

8. เขยี นโปรแกรมเพอ่ื รบั ขอ มลู เลขจาํ นวนจริงจากผูใช 3 จาํ นวน ใหหาวาคาที่มากที่สุดที่ปอนเขามาคือคา

ใด โดยใชตัวดาํ เนนิ การเงอ่ื นไข

คาํ สั่งควบคุม 3

(Control Statements )

ในการเขียนโปรแกรมแบบโครงสราง จะมรี ปู แบบการแกป ญ หาหรอื รปู แบบการเขยี นโปรแกรมอยู 3
ลกั ษณะ คือ การเขียนแบบลําดับ (Sequential) การเขยี นแบบเงอ่ื นไข (Selection) และการเขียนแบบวนซํ้า
(Repetition) การเขยี นทลี ะคาํ สั่งจากบนลงจัดเปนการเขียนแบบลําดับ สวนการเขียนแบบเงื่อนไขและการ
เขยี นแบบวนซาํ้ นนั้ จะตอ งใชคาํ สั่งควบคุมมาชวยใหเกิดการเขียนในลกั ษณะดังกลา ว โดยที่ใชภาษาซีมีคาํ สั่ง if
และ switch เพอื่ ชวยในการเขียนแบบเงื่อนไข สว นในการเขยี นแบบวนซ้ําจะมี 3 คาํ สั่งคือ for while และ
do-while

1. คาํ สงั่ if
คาํ ส่งั if เปน คาํ สง่ั ทใ่ี ชใ นการเขยี นแบบเงอ่ื นไข ตัวอยางของประโยคในลักษณะเงื่อนไขเปนตัวอยางที่
สามารถพบเห็นไดในชีวิตประจาํ วัน เชน

ถา วนั นฝ้ี นไมต ก ฉนั จะเดนิ ไปโรงเรยี น แตถาฝนตก ฉนั จะขอใหค ณุ พอ ไปสง ทโ่ี รงเรยี น
หรอื ตัวอยางเชน

ถา ฉนั สอบไดค ะแนนดี คุณพอและคุณแมจะภูมิใจ
จะใหว า ประโยคเงื่อนไขดังกลาวมีอยู 2 ลกั ษณะ คือ ถาเงื่อนไขเปนจริงเกิดเหตุการณหนึ่ง แตถาไม
จรงิ จะเกดิ อกี เหตกุ ารณหน่งึ กับประโยคในลักษณะที่ถาเงื่อนไขเปนจริงจึงจะเกิดเหตุการณขึ้นเทานั้น ทง้ั 2
ลกั ษณะสามารถเขียนเปนผังงานของงานไดดังรูปที่ 3.1 (ก) และ (ข)

รปู ท่ี 3.1 แสดงผังงานของประโยคเงื่อนไข

36

จากผงั งานทั้ง 2 จะมีรูปแบบการเขียนคาํ สง่ั if เกิดขึ้น 2 แบบ

1.1 คาํ ส่ัง if-else

คําสง่ั if ในรปู แบบแรกจะคําสั่งที่ตองทําทั้งในกรณีที่เงื่อนไขเปนจริงและเปนเท็จ โดยใช
นิพจนตรรกศาสตรมาเปนเครื่องมือชวยในการตรวจสอบเงื่อนไข มรี ปู แบบคาํ สัง่ คือ

if ( เงื่อนไข )
คาํ สั่งที่ 1;

else
คาํ สั่งที่ 2;

ตวั อยา งเชน หากรับขอมูลจากผูใชและตองการตรวจสอบวาเลขที่รับเขามามีคามากกวา 10
ใหพ ิมพขอความวา “Number XXXX is over than 10” แตถ า ไมใชใหพิมพขอความวา “Number
XXXX is not over than 10” จะเขยี นเปน คําสั่งไดวา

scanf(“%d”, &number);
if (number > 10)

printf(“Number %d is over than 10”, number);
else

printf(“Number %d is not over than 10”, number);

แตห ากเงอ่ื นไขเปน จรงิ หรอื เทจ็ แลว ตอ งทําคาํ สั่งมากกวา 1 คําสัง่ จะตองใชเขียน if-else ใน
รปู แบบทใ่ี ชเ ครอ่ื ง { } ซงึ่ แสดงขอบเขตของการทําเงื่อนไข ครอบคาํ สั่งที่ตองทําในแตล ะเงอ่ื นไข มีรูป
แบบดังนี้

if ( เงื่อนไข ) {
คาํ สั่งที่ 1;
คาํ สั่งที่ 2;
….

} else {
คาํ สั่งที่ 3;
คาํ สั่งที่ 4;
…

}

37

ตวั อยา งเหมอื นในตวั อยา งกอ นหนา น้ี แตเพิ่มเงื่อนไขวา ถาเลขนั้นมีคามากกวา 10 ใหล ด
เลขนน้ั ลง 5 แสดงไดดังตัวอยาง

scanf(“%d”, &number);
if (number > 10) {

printf(“Number %d is over than 10”, number);
number = number – 5;
} else
printf(“Number %d is not over than 10”, number);

แตห ากมเี งอ่ื นไขเพม่ิ ขน้ึ อกี วา ถาเลขนั้นไมมากกวา 10 ใหเพิ่มคาเลขนั้นขึ้นอีก 5 สามารถ
เขียนไดวา

scanf(“%d”, &number);
if (number > 10) {

printf(“Number %d is over than 10”, number);
number = number – 5;
} else {
printf(“Number %d is not over than 10”, number);
number = number + 5;
}

ทง้ั นห้ี ากมคี าํ สงั่ เพียงคําสั่งเดียวในเงื่อนไข ก็สามารถใชเครื่องหมาย { } ไดเชนเดียวกัน เชน
scanf(“%d”, &number);
if (number > 10) {
printf(“Number %d is over than 10”, number);
} else {
printf(“Number %d is not over than 10”, number);
}

แสดงตวั อยางโปรแกรมดังตัวอยางที่ 3.1 และตัวอยางที่ 3.2

38

ตวั อยา งที่ 3.1 โปรแกรมเพื่อตรวจสอบความสูงของนักเรียน 2 คน โดยรับขอมูลความสงู ของนักเรียน
ทง้ั สองมาหาวาความสงู มากที่สุดคือคาใด

#include <stdio.h>
void main( ) {

float height1, height2, max;
printf(“Enter first student’s height (cm.) : “);
scanf(“%f”, &height1);
printf(“Enter second student’s height (cm.) : “);
scanf(“%f”, &height2);
if (height1 > height2)

max = height1;
else

max = height2;
printf(“Maximum height is : %.2f cm.”, max);
}

ผลการทํางานของโปรแกรม
Enter first student’s height (cm.) : 184.5
Enter second student’s height (cm.) : 192.4
Maximum height is : 192.40 cm.

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

#include <stdio.h>
void main( ) {

float w, h, BMI;
printf(“Enter weight (Kg): “);
scanf(“%f”, &w);
printf(“Enter height (M): “);
scanf(“%f”, &h);
BMI = w / (h * h);
printf(“BMI is %.2f”, BMI);
if (BMI >= 20 && BMI <= 25)

printf(“\nNormal BMI.”);

39

else
printf(“\nDangerous BMI.”);

}

1.2 คาํ สัง่ if

ในกรณที ป่ี ระโยคเงอ่ื นไขมกี ารทํางานเฉพาะเงื่อนไขที่เปนจริงเทานั้น โดยไมมีการทาํ งานใด
ในเงอ่ื นไขทเ่ี ปน เทจ็ ดังแสดงในรูปที่ 3.1 (ข) สามารถเขียนแทนดวยคาํ สั่ง if โดยไมตองใสคาํ สง่ั
else แสดงดังรูปแบบ

if ( เงื่อนไข )
คาํ สั่งที่ 1;

แตถ า เงอื่ นไขเปนจริงแลวมีการทาํ คาํ สั่งมากกวา 1 คาํ สง่ั ขน้ึ ไป กใ็ ชรูปแบบของเครอ่ื งหมาย
{ } ซงึ่ ใชใ นกรณที ม่ี คี าํ สั่งที่ตองทําในเงื่อนไขและการวนซาํ้ มากกวา 1 คําสัง่ เพื่อแสดงขอบเขตของ
การทาํ งานนั้น

ตวั อยา งเชน ใหรับขอมูลจาํ นวนเต็มจากผูใช หากขอมูลนั้นมีคามากกวา 60 หรอื นอ ยกวา
20 ใหข ึ้นขอความวา “Number XXXX is out of range” เขยี นไดดังตัวอยาง

scanf(“%d”, &number);
if (number < 20 || number > 60)

printf(“Number %d is out of range”, number);

แสดงตวั อยา งการใชงานแสดงดังตัวอยางที่ 3.3 และ 3.4

ตวั อยา งที่ 3.3 โปรแกรมเพอื่ ใหผูใชคาดเดาตัวอักษรที่โปรแกรมไดตั้งไว ถาผูใชปอนขอมูลตัวอักษร
ตรงกบั ตวั อักษรตรงกับสิ่งที่โปรแกรมตั้งไวจะขึ้นคาํ วา “Bingo”

#include <stdio.h>
#define ANS ‘G’
void main( ) {

char ch;
printf(“Enter character (a-z/A-Z) : “);
scanf(“%c”, &ch);
if (ch == ANS)

printf(“Bingo”);
}

40

ผลการทํางานของโปรแกรม

Enter character (a-z/A-z) : G
Bingo

ระวัง - หากพิมพคาํ ส่งั ch == ANS เปน คําสงั่ ch = ANS จะไดผ ลลพั ธก ารทํางานที่แตกตางกัน
- การเปรียบเทียบ ch == ANS คอื การสั่งใหเปรียบเทียบวา ch == ‘G’

ตวั อยางที่ 3.4 แสดงโปรแกรมเพื่อรับขอมูลเลขจาํ นวนเต็ม 2 จาํ นวนจากผูใช หากคาแรกที่รับมามี
คา มากกวาคาหลงั ใหขึ้นขอความวา “First value more than second value.”

#include <stdio.h>
void main( ) {

int a, b;
printf(“Enter A : “);
scanf(“%d”, &a);
printf(“Enter B : “);
scanf(“%d”, &b);
if (a > b)

printf(“First value more than second value”);
}

1.3 คาํ สั่ง if แบบซับซอน

ในบางกรณปี ระโยคเงื่อนไขอาจจะมีความซับซอน มีการเปรียบเทียบเงื่อนไขเดียวกันกับหลายคา เชน
ใหร บั ขอ มลู ชั้นปของนักศึกษาและใหพิมพขอความตรงกับชั้นป กาํ หนดวาชน้ั ปท ่ี 1 พิมพวา “Freshman” ชน้ั ป
ท่ี 2 พิมพวา “Sophomore” ชน้ั ปท ่ี 3 พิมพวา “Junior” ชน้ั ปท ่ี 4 พิมพวา “Senior” ชน้ั ปอ น่ื ๆ พิมพวา “Super”

scanf(“%d”, &year);
if (year == 1)

printf(“Freshman”);
else if (year == 2)

printf(“Sophomore”);
else if (year == 3)

printf(“Junior”);
else if (year == 4)

printf(“Senior”);
else

printf(“Super”);

41

นอกจากนบี้ างเงอื่ นไขอาจจะมีความซับซอน เชน พิจารณาขอมูลนักศึกษา ใหตรวจสอบวาถาเปนนัก
ศกึ ษาเพศชายมคี วามสงู ตง้ั แต 180 ซม. ขน้ึ ไป ใหขึ้นขอความแนะนําวาควรจะสมัครเขาชมรมบาสเก็ตบอล แต
ถา เปน เพศหญงิ มคี วามสูงต้งั แต 170 ซม. ขน้ึ ไป ใหขึ้นขอความแนะนําวาควรจะสมัครเขาชมรมวอลเลยบอล

if (gender == ‘M’ && height > 180)
printf(“Basketball”);

else if (gender == ‘F’ && height > 170)
printf(“Volleyball”);

สามารถเขียนในอีกลักษณะหนึ่งไดวา

if (gender == ‘M’) {
if (height > 180)
printf(“Basketball”);

} else { /* ไมใ ชเพศชาย เพราะฉะนั้นเปนเพศหญิง */
if (height > 170)
printf(“Volleyball”);

}

การเขยี นในลกั ษณะดังกลาวจะตองระมัดระวังเรื่องการใชเครื่องหมาย { } ใหถ กู ตอ ง

พจิ ารณาจากตัวอยางตอไปน้ี

if (gender == ‘M’) เหมือนกับ if (gender == ‘M’)
if (height > 180) if (height > 180)
printf(“Basketball”); printf(“Basketball”);
else if (height > 170)
else printf(“Volleyball”);
if (height > 170)
printf(“Volleyball);

จะเหน็ วา การเวนยอหนาไมชวยใหเกี่ยวของกับการจับคูของเงื่อนไข if-else เวลาทค่ี อมไพเลอรม องดู
โปรแกรมไมไ ดด จู ากการยอ หนา แตดูจากสัญลักษณตาง ๆ การตีความจึงแตกตางจากความตั้งใจของผูเขียน
โปรแกรม เพราะฉะนั้นหากไมแนใจการจับคูเงื่อนไขใด ใหใชเครื่องหมาย { } เปน ตัวบอกขอบเขตการทาํ งาน
ของคาํ สง่ั if-else นน้ั ๆ โดยที่จาํ นวนปกกาเปดจะในโปรแกรมจะตองเทากับจาํ นวนปกกาปด ในโปรแกรมเสมอ
แสดงตวั อยางโปรแกรมดังตัวอยางที่ 3.5 และ 3.6

42

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

คะแนนตา่ํ กวา 50 ไดเกรด F
คะแนนตา่ํ กวา 60 ไดเกรด D
คะแนนตา่ํ กวา 70 ไดเกรด C
คะแนนตา่ํ กวา 85 ไดเกรด B
คะแนนตั้งแต 85 ขน้ึ ไปไดเ กรด A

#include <stdio.h>
void main( ) {

float score;
printf(“Enter score : “);
scanf(“%f”, &score);
if (score < 50)

printf(“Grade F”);
else if (score < 60)

printf(“Grade D”);
else if (score < 70)

printf(“Grade C”);
else if (score < 85)

printf(“Grade B”);
else

printf(“Grade A”);
}

ตวั อยา งที่ 3.6 ใหร บั ขอ มลู จํานวน 3 จํานวนจากผูใช และใหหาวาคามากที่สุดมีคาเทาใด

#include <stdio.h>

void main( ) {
int first, second, third, max;
printf(“Enter first number : “);
scanf(“%d”, &first);
printf(“Enter second number : “);
scanf(“%d”, &second);
printf(“Enter third number : “);
scanf(“%d”, &third);
max = first;
if (max > second)
max = second;

43

else if (max > third)
max = third;

printf(“Maximum number is %d”, max);
}

ในทนี่ ลี้ องพิจารณาตัวอยางของ Short Circuit ทไ่ี ดก ลา วถงึ ในบทท่ี 2 กบั การใชงานประโยคเงื่อนไข
สงิ่ ทต่ี อ งระวังคือ หากใชเครื่องหมาย && (Logical And) ถา นพิ จนแ รกเปน เทจ็ จะทําใหนพิ จนนนั้ เปน เทจ็ เสมอ
และถาเปนเครื่อง || (Logical Or) หากนพิ จนแ รกเปนจริง จะทําใหทั้งนิพจนเปนจริงเสมอ สิ่งที่ตามมาคือ
คอมไพเลอรจ ะไมม กี ารประมวลผลคําสั่งในนิพจนที่คูกัน เรียกกระบวนการนี้วา Short-circuit แสดงดังตัวอยาง

int a = 10;
if (a > 5 || a++ > 10)

a = a * 2;
printf(“a = %d”, a);

จะไดคําตอบวา a = 20 ทง้ั นห้ี ากสงั เกตนพิ จนท ่ี 2 ของการเปรยี บเทียบจะเห็นวา ผูเขียนโปรแกรม
ตง้ั ใจใหม กี ารเพม่ิ คา ของ a ขน้ึ อกี 1 กอนทจ่ี ะทาํ งานใด ๆ แตเนื่องจากนิพจนแรกเปนจริง ทาํ ใหสรุปไดวาทั้ง
นพิ จนน เ้ี ปน จรงิ จึงไมมกี ารประมวลผลนพิ จนท ่ี 2 คา a จงึ ไมเ พมิ่ ขนึ้ ซึ่งอาจจะทําใหคาที่ไดผดิ จากความตั้งใจ
ของผเู ขยี นโปรแกรม

ตวั อยางของ Short-circuit ทใี่ ชเครื่องหมาย && ไดแ ก

int a = 10;
if (a < 5 && a++ > 10)

a = a * 2;
printf(“a = %d”, a);

จะไดค ําตอบคือ a = 10 เนอื่ งจากนิพจนแรกเปนเท็จ ทาํ ใหเ กิด Short-circuit ไมม กี ารประมวลผล
นพิ จนท ่ี 2 คา a จงึ ไมมีการเพิ่มขึ้น

นอกจากนห้ี ากเปรยี บเทยี บตวั ดาํ เนนิ การเงอ่ื นไขทไ่ี ดก ลา วถงึ ในบทท่ี 2 สามารถเปรียบเทียบไดกับการ
ทาํ งานประโยคเงอ่ื นไข if-else ดงั ตวั อยาง

x = (y < 0) ? -y : y;

หากเขยี นคาํ สั่งดังกลาวเปนประโยคเงอื่ นไข if-else จะได

if (y < 0)
x = -y;

else
x = y;

44

2. คาํ ส่ัง switch

คาํ ส่งั switch เปน คาํ สงั่ ที่ใชในการเขียนประโยคเงื่อนไข มักจะใชกับกรณีที่เปนเงื่อนไข if แบบซบั ซอ น
ตวั อยา งเชน ในเรื่องของการตรวจสอบชั้นปของนักศึกษา และใหพิมพขอความตามชั้นปที่กาํ หนด ดังตัวอยางที่
แสดงในหวั ขอ 3.1.3 จะเห็นวามีการตรวจสอบนิพจนเ งื่อนไข คือ ชั้นปของนักศึกษาในทุกเงื่อนไขเหมือนกัน
ประโยคในลกั ษณะเชนนี้สามารถใชคาํ ส่งั switch มาชว ยในการเขียน เพื่อชวยใหอานเขาใจไดมากยิ่งขึ้น ท้งั น้ี
เงอ่ื นไขทจ่ี ะนาํ มาตรวจสอบในคาํ สงั่ switch ไดจ ะตอ งมีคาเปนเลขจาํ นวนเต็มหรือตัวอักขระเทานั้น ไม
สามารถใชก บั การตรวจสอบสตรงิ หรือขอมลู ท่มี ลี ักษณะเปนชวง มีรูปแบบของคาํ สง่ั switch คือ

switch ( เงื่อนไข ) {
case คา คงที่1 : คาํ สั่ง1 ;
case คา คงท2่ี : คาํ สงั่ 2 ;

default : คาํ สงั่ N ;
}

การทํางานของคาํ สงั่ switch จะตรวจสอบเงอ่ื นไข วาตรงกับคา case ใด กจ็ ะไปทํางานที่คาํ สั่งที่อยู
ใน case นน้ั คาํ สั่งหนึ่งที่มักจะใชคูกับคาํ สงั่ switch คือ คาํ ส่ัง break คาํ สง่ั นใี้ ชในการบอกใหโปรแกรมหยดุ
การทาํ งาน และกระโดดออกจากขอบเขตของ { } ทใ่ี กลท สี่ ดุ ซึ่งสามารถใชคําสั่งนี้รวมกับคาํ สั่งวนซาํ้ อื่น ๆ อกี
ดว ย พิจารณาการทาํ งานของคาํ ส่งั switch จากตัวอยาง

int a=2; int a=2;
switch ( a ) { switch ( a ) {

case 1 : printf(“11111\n”); case 1 : printf(“11111\n”);
case 2 : printf(“22222\n”); break;
case 3 : printf(“33333\n”);
default : printf(“AAAAA\n”); case 2 : printf(“22222\n”);
} break;

case 3 : printf(“33333\n”);
break;

default : printf(“AAAAA\n”);
}