CProgrammingV2

45

ผลการทํางาน (ก) ผลการทํางาน (ข)
22222 22222
33333

AAAAA

• จากตวั อยาง ก เมื่อโปรแกรมตรวจสอบนิพจนว าตัวแปร a มคี า เทากับ 2 จะมาทํางานที่คาํ สง่ั
case 2 พมิ พค า 22222 และทาํ คาํ สั่งตอ ๆ มาไดผ ลลพั ธด งั ตัวอยาง

• ตวั อยาง ข มีการใชคําสัง่ break เมอื่ มกี ารตรวจสอบวาตัวแปร a มคี า เทากับ 2 จะมาทํางานที่คาํ
สง่ั case 2 พมิ พค า 22222 และทาํ คาํ สัง่ break ซง่ึ จะทาํ ใหก ารทาํ งานกระโดดออกจาก

ขอบเขตของเครื่องหมาย { } ทใ่ี กลท ส่ี ดุ ไดผ ลลพั ธด งั ตวั อยา ง

คาํ ส่ัง default ใน switch จะมีคาเหมือนกับ else ในคําส่ัง if-else กค็ อื คา ใด ๆ ก็ตามที่ไมใชคาที่
กาํ หนดใน case จะมาทาํ ที่คําสง่ั default ซงึ่ คาํ สั่ง default นจ้ี ะมหี รอื ไมม กี ไ็ ด หากเขียนคาํ สง่ั switch แทนคาํ
สง่ั if-else ของการพมิ พคาของชั้นปนักศึกษาจะไดดังตัวอยาง

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

printf(“Freshman”); case 1 : printf(“Freshman”);
else if (year == 2) break;

printf(“Sophomore”); case 2 : printf(“Sophomore”);
else if (year == 3) break;

printf(“Junior”); case 3 : printf(“Junior”);
else if (year == 4) break;

printf(“Senior”); case 4 : printf(“Senior”);
else break;

printf(“Super”); default : printf(“Super”);
}

นอกจากนี้ยังสามารถเขียนคาํ สง่ั switch ในลกั ษณะอน่ื ๆ แสดงดังตัวอยางที่ 3.7 และ 3.8

46

ตวั อยางที่ 3.7 เขยี นโปรแกรมเพื่อรับขอมูลตัวอักษรจากผูใช หากผูใชปอนตัวอักษร a, b, x ใหขึ้น
ขอ ความวา “Hanaga” ปอ นตัวอักษร u, d, p ใหข ึ้นขอความวา “Bingo” ปอ นตัวอักษร g ใหข ึ้นขอความวา
“Google” ปอ นตัวอักษรอื่น ๆ ใหขึ้นขอความวา “Yappadappadoooo”

#include <stdio.h>

void main( ) {
char ch;
printf(“Enter character : “);
scanf(“%c”, &ch);
switch ( ch ) {
case ‘a’ :
case ‘b’ :
case ‘x’ : printf(“Hanaga”);
break;

case ‘u’ :
case ‘d’ :
case ‘p’ : printf(“Bingo”);

break;
case ‘g’ : printf(“Google”);

break;
default : printf(“Yappadappadoooo”);
}
}

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

ทาํ งานและประเภทพนกั งาน ซึ่งพนักงานแตละประเภทไดรับคาจางตอชั่วโมงตางกันดังนี้

ประเภทของงาน อตั ราคาจาง / ชั่วโมง

0 30

1 40

2 45

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

float workRate, totalPay;
int workHours;

47

char type;
clrscr();
printf("Enter type (1-3) : ");
scanf("%c", &type);
flushall();
if (type == '1' || type == '2' || type == '3') {

switch (type) {
case '1' : workRate = 30.0f;
break;

case '2' : workRate = 40.0f;
break;

default : workRate = 45.0f;
}
printf("Enter work hours : ");
scanf("%d", &workHours);
flushall();
totalPay = workHours * workRate;
printf("Rate is %.2f, total pay = %.2f", workRate, totalPay);
} else
printf("!!!Error : incorrect employee type");
getch();
}

48

3. คาํ ส่งั for
คาํ สง่ั วนซา้ํ เปน คาํ สั่งใชแกปญหาโจทยในลักษณะที่มีการทาํ งานเดิมซํา้ กันหลาย ๆ ครั้ง ซึ่งเขียนในรูป

แบบของผังงานไดดังรูปที่ 3.2

รปู ท่ี 3.2 แสดงผังงานของคําส่งั for
คําส่ัง for เปน คาํ สง่ั วนซา้ํ ในลักษณะที่รูจาํ นวนรอบของการวนซํา้ ทแ่ี นน อน โดยแบง รปู แบบหลกั ออก
เปน 3 สว น ไดแ ก

• สว นทใี่ ชก าํ หนดคาเริ่มตนหรือกาํ หนดคาตวั นบั ของการวนซาํ้
• สว นที่ตรวจเงื่อนไขการวนซาํ้
• สว นของการจัดการคาตัวนับของการวนซาํ้
for ( กาํ หนดคา ตวั นบั ; เงื่อนไขการวนซาํ้ ; จดั การคาตัวนับ ) {

คาํ สั่ง1;
คาํ สงั่ 2;
}

ขนั้ ตอนของการทาํ งานเมื่อพบคําสั่ง for มีดังนี้
1. ทาํ คาํ สั่งในการกาํ หนดคา ตวั นบั
2. ตรวจสอบเงอื่ นไขการวนซาํ้ หากเปนเท็จจะหยุดและออกจากการทาํ งานของคาํ สง่ั for ไปทาํ งาน

คาํ สั่งหลังจากนั้น

49

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

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

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

#include <stdio.h>

void main( ) {
int i, number;
float average, sum=0.0f;

for ( i=0 ; i < 5 ; i++) {
printf(“Enter number %d : “, i+1);
scanf(“%d”, number);
sum += number;

}
average = sum / 5;
printf(“Average is %.2f”, average);
}

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

Enter number 1 : 10
Enter number 2 : 20
Enter number 3 : 30
Enter number 4 : 40
Enter number 5 : 50
Average is 30.00

ระวงั - หากกาํ หนดใหตัวแปร sum เปน ขอ มลู ชนดิ int การสั่งให average = sum / 5; จะทาํ ใหเกิด
การปดเศษทิ้ง

50

ในการทํางานของคาํ ส่ัง for สง่ิ สาํ คญั ทผ่ี ใู ชจะตอ งรูคอื ทําอยางไรจึงจะวนทําซํ้าไดเทากับจาํ นวนรอบ
ทตี่ อ งการ จากตัวอยางที่ 3.9 มีการใชตัวแปร i เปน ตวั นบั จาํ นวนรอบของการทาํ ซํ้า ในที่นี้ตองการใหมีการทํา
ซาํ้ ทง้ั หมด 5 รอบ ไลข น้ั ตอนการทํางานของโปรแกรมไดดังนี้

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

มานั้นเก็บไวในตัวแปร sum
3. เพิ่มคา i ขนึ้ 1 เพราะฉะนน้ั i มคี าเทากับ 1
4. แลวตรวจสอบวา i มคี า นอยกวา 5 เงอื่ นไขเปนจริง มีรบั ขอ มูลตวั ท่ี 2 และทาํ การบวกเลขที่รับเขา

มานั้นเก็บไวในตัวแปร sum
5. เพิ่มคา i ขนึ้ 1 เพราะฉะนน้ั i มคี า เทา กับ 2
6. แลวตรวจสอบวา i มคี า นอยกวา 5 เงอื่ นไขเปนจริง มรี บั ขอมูลตวั ที่ 3 และทาํ การบวกเลขที่รับเขา

มานั้นเก็บไวในตัวแปร sum
7. เพิ่มคา i ขนึ้ 1 เพราะฉะนน้ั i มคี าเทากับ 3
8. แลวตรวจสอบวา i มคี า นอยกวา 5 เงอื่ นไขเปนจริง มีรับขอมลู ตัวท่ี 4 และทาํ การบวกเลขที่รับเขา

มานั้นเก็บไวในตัวแปร sum
9. เพิ่มคา i ขนึ้ 1 เพราะฉะนน้ั i มคี า เทากับ 4
10. แลวตรวจสอบวา i มคี า นอยกวา 5 เงอื่ นไขเปนจริง มรี บั ขอมูลตวั ที่ 5 และทาํ การบวกเลขที่รับเขา

มานั้นเก็บไวในตัวแปร sum
11. เพิ่มคา i ขนึ้ 1 เพราะฉะนน้ั i มคี า เทากับ 5
12. ตรวจสอบเงอ่ื นไข i มคี า นอ ยกวา 5 พบวา เงอ่ื นไขเปน เทจ็ ก็จะจบการทาํ งานภายในคาํ สั่ง for

พจิ ารณาคา ของการวนซา้ํ ตอ ไปน้ี วาคาเริ่มตนของตัวนับการทาํ ซํ้าเปน เทา ใด ทาํ ซํ้าทั้งหมดกี่รอบ
และคา สดุ ทา ยของตัวนบั ที่ออกจากการทาํ ซํ้าเปน เทา ใด จากตาราง 3.1

ตาราง 3.1 หาคาของการทาํ งานวนซํา้ ดวยคําสัง่ for

คาํ สั่ง คา ตัวนับเริ่มตน จาํ นวนรอบ คา ตัวนับสุดทาย
6
for ( i = 1; i <= 5; i++) 15 58
5
for ( j = 53; j <= 57; j++) 53 5 20
32
for (k = 10; k > 5; k- -) 10 5

for (a = 2; a < 20; a += 2) 29

for (a = 2; a < 20; a *= 2) 24

จะเหน็ วาคาํ สั่งสวนตาง ๆ ของคาํ ส่ัง for สามารถเขยี นไดห ลายรปู แบบ แตมีสุดทายที่ตองการคือการ
ควบคมุ จาํ นวนรอบของการทําซํ้าใหไดเทากับจาํ นวนที่ผูเขียนโปรแกรมตองการ

51

สงิ่ ทตี่ องระวังในการเขียนคือ

for (i = 0; i < 5; i++);
printf(“Hello\n”);

การใสเ ครอ่ื งหมาย ; ตอ ทายคาํ สั่ง for เครื่องหมาย ; เปน คาํ สั่งที่เรียกวา Null Statement นบั เปน
คาํ สง่ั 1 คาํ สง่ั โดยท่คี าํ สง่ั นี้จะไมท ําอะไรเลย เพราะฉะนั้นในตัวอยางดังกลา ว จะมีการวนทําซํ้าโดยไมทาํ
อะไรเลย 5 รอบ แลวจึงพิมพขอความ Hello เพยี งขอ ความเดยี ว แทนที่จะพิมพขอความ Hello 5 ครง้ั

นอกจากนท้ี พ่ี บเหน็ บอ ย ๆ คือการใชเครื่องหมาย ; ตอ ทายคาํ ส่งั if ซงึ่ จะใหผลเชนเดียวกับตัวอยาง
ขางตน เชน

if (a > 5);
printf(“Hello”);

จากการใสเ ครื่องหมายดังกลาวคอมไพเลอรจะตีความไดวา ตรวจสอบวา a มคี า มากกวา 5 หรอื ไม
ถา มากกวาก็ไมตองทําอะไร ( ทํา Null Statement คือ ; ) แลว ไปพิมพขอความวา Hello แทนที่จะทาํ การตรวจ
สอบวา ถา a มคี า มากกวา 5 ใหพิมพขอความวา Hello

ตวั อยางการใชคาํ สัง่ for เพมิ่ เติม คือ คําสั่ง for สามารถใชตัวดาํ เนินการคอมมา ( , ) ประกอบภายใน
คาํ สง่ั หรอื อาจจะเขียนองคประกอบของคาํ สั่งไมครบก็ได แสดงดังตัวอยาง

for (i=0, j=0; i<5 && i+j < 10; i++, j+=2) {
……

}
a = 0;
for ( ; a < 5 ; ) {

……
a++;
}

ตวั อยา งเพิ่มเติมในเรื่องของคําสั่ง for แสดงดงั ตัวอยางที่ 3.10 และ 3.11

ตวั อยางที่ 3.10 โปรแกรมเพื่อหาคาเฉลี่ยของเลขจาํ นวนเต็ม N ตวั ซงึ่ รับจากผูใช

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

int i, number, n;
float average, sum=0.0f;

52

printf(“Enter N : “);
scanf(“%d”, &n);
for ( i=0 ; i < n ; i++) {

printf(“Enter number %d : “, i+1);
scanf(“%d”, number);
sum += number;
}
average = sum / 5;
printf(“Average is %.2f”, average);
}

ตวั อยา งที่ 3.11 โปรแกรมเพอ่ื แสดงผลลพั ธข องการแปลงเลขฐาน 10 ใหเปนเลขฐาน 8 และเลขฐาน
16 โดยรบั ขอ มูลคาเริ่มตนและคาสุดทายของชวงขอมูลที่ตองการแปลงคา

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

int start, end, i;
printf(“Enter start number : “);
scanf(“%d”, &start);
printf(“Enter end number : “);
scanf(“%d”, &end);
printf(“\n\tDec\t\t\tOctal\t\t\tHexa”);
for ( i=start ; i <= end ; i++) {

printf(“\n\t%3d\t\t\t%5o\t\t\t%4x”, i, i, i);
}
}

นอกจากนย้ี งั มคี าํ สงั่ เพิ่มเติมที่จะพบไดเมื่อมีการใชการทาํ งานวนซํา้ ในลักษณะตางทั้งคาํ ส่ัง for คาํ ส่ัง
while และคาํ ส่ัง do-while คาํ สงั่ ดังกลาวไดแก คาํ สงั่ continue คาํ สง่ั นจ้ี ะทาํ งานคลายกับคาํ สงั่ break ซึ่ง
เปน การบอกใหจ บการทํางานในขอบเขตที่คาํ สั่งอยู และออกจากคาํ สั่งวนซาํ้ นั้น คําส่ัง continue จะบอกใหจ บ
การทาํ งานในขอบเขตทค่ี าํ สั่งอยูเชนเดียวกัน แตจ ะวนกลบั ไปยงั ทําคาํ สั่งวนซาํ้ นน้ั ในรอบถดั ไปแทน พิจารณา
จากตวั อยาง โดยที่ใหมีการรับขอมูลเลขจาํ นวนเต็ม N จาํ นวนจากผใู ช ใหหาผลรวมของเลขคูที่รับเขามา แต
หากผลรวมนั้นมาคามากกวา 200 ใหห ยดุ การหาผลรวม ถาเมื่อใดปอนเลข 0 เขามาใหหยุดการรับขอมูลทันที
จะไดวา

53

printf(“Enter N : “);
scanf(“%d”, &n);
sum = 0;
for (i=0; i < N; i++) {

printf(“Enter number %d : “, i);
scanf(“%d”, &number);
if (number == 0)

break;
else if (number % 2 == 0) {

if (sum > 200)
continue;

sum += number;
}
}

เมื่อใดที่คา sum มคี า มากกวา 200 จะมีการทาํ คาํ สง่ั continue ซงึ่ มผี ลทําใหไ มม กี ารประมวลผลคาํ สง่ั
ทเ่ี หลอื แตจ ะกลบั ไปทําคาํ สงั่ i++ และตรวจสอบเงอ่ื นไขของ i < N ถา เงอ่ื นไขเปน จรงิ กจ็ ะวนทํางานซํา้ ตอไป

4. คาํ สงั่ while

คําสงั่ while เปน คาํ สง่ั วนซา้ํ มักใชในกรณีที่ตองทํางานซํา้ กันหลาย ๆ ครัง้ โดยไมทราบจาํ นวนรอบ
ของการทาํ ซํ้าทแ่ี นน อน ตัวอยางเชน

ตอ งการรบั ขอ มลู เลขจํานวนเต็มบวกจากผูใชจาํ นวนหนึ่งเพื่อนํามาหาคาเฉลี่ยของตัวเลขที่ปอนเขามา
ทั้งหมด

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

54

รปู ท่ี 3.3 ผงั งานของการทาํ งานคําสง่ั while
หากแทนผังงานดังกลาวดวยคาํ สัง่ while สามารถเขียนรูปแบบของคาํ สงั่ while ไดดังนี้

while ( เงอ่ื นไข ) {
คาํ สั่ง1 ;
คําสั่ง2 ;

}
จากรปู แบบคาํ สง่ั ดงั กลา ว จะเกิดการทาํ งานคําสั่ง1 และคาํ ส่งั 2 เมื่อมีการตรวจสอบวาเงื่อนไขเปน
จรงิ และจะทาํ งานซาํ้ เชนนี้ไปจนกวาเงื่อนไขนั้นจะเปนเท็จ หากคาํ ส่ังท่ีทําซํ้ามีมากกวา 1 คําสั่งจะตองใชเครื่อง
หมายแสดงขอบเขต คือ { } ครอบคาํ สั่งที่ตองการใหทําซํ้าทั้งหมด แตถ า มคี าํ สั่งที่ตองทําซํ้าเพียงคาํ สั่งเดียว ผู
เขยี นโปรแกรมใสเครื่องหมาย { } หรอื ไมก ไ็ ด
ทงั้ นตี้ อ งระวังหามใสเครื่องหมาย ; หลงั วงเล็บของเงือ่ นไข ซึ่งถือเปนคําส่ัง Null Statement ดงั อธิบาย
ในหวั ขอ 3.4 แสดงตัวอยางโปรแกรมดวยตัวอยางที่ 3.12
ตวั อยา งที่ 3.12 โปรแกรมเพอื่ หาคาเฉลีย่ ของเลขจาํ นวนเต็มบวกที่ผูใชปอนเขาสูระบบ เมื่อใดที่ผูใช
ปอ นเลขจํานวนเต็มลบใหถือวาสิ้นสุดการปอนขอมูล

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

int number, count;
float sum, average;

55

count = 0;
sum = 0.0f;
printf(“Enter number : “);
scanf(“%d”, &number);
while ( number >= 0) {

sum += number;
count++;
printf(“Enter number : “);
scanf(“%d”, &number);
}
average = sum / count;
printf(“Average is %.2f”, average);
}

จากตวั อยา งเนอื่ งจากจะตองหาคาเฉลี่ยของเลขจาํ นวนเต็มบวกที่ปอนเขามาจึงใชตัวแปร count ใน

การนบั จาํ นวนตัวเลขจาํ นวนเต็มบวกที่ปอนเขามาทั้งหมด และมีเงื่อนไขในการทําซํ้าคือ number >= 0 ถา

ตราบใดทผี่ ใู ชป อ นขอมูลเขามามีคามากกวาหรือเทากับ 0 ก็จะเกิดการหาคาผลรวมของขอมูลนั้น และนบั

จาํ นวนขอ มลู ทร่ี บั เขามา ตลอดจนรับขอมูลตัวใหมเขาตรวจสอบวาตรงกับเงื่อนไขของการทําซํ้าหรอื ไม จนกวา

จะมกี ารปอ นขอมูลนอยกวา 0 จึงจะมีการคาํ นวณหาคาเฉลี่ย และแสดงผลลพั ธท างจอภาพ

หากสงั เกตรปู แบบการเขียนตัวอยางดังกลาว จะเขียนเปนโครงรางไดดังนี้

printf(“Enter number : “); กาํ หนดคาเริ่มตนใหคาควบคมุ
scanf(“%d”, &number);

while (number >= 0) { เงอื่ นไขคาควบคมุ การทําซํ้า

….

printf(“Enter number : “); เปลย่ี นแปลงคา ควบคุม
scanf(“%d”, &number);

}

ในการทํางานของคาํ สัง่ while จะมตี วั ควบคมุ การทาํ ซํ้าเสมอ ซึ่งจะตองมีการกําหนดคาเริ่มตนของคา

ควบคมุ ตรวจสอบเงื่อนไขคาควบคุม และมีการเปลี่ยนแปลงคาควบคุม เพอ่ื นําไปตรวจสอบเงอ่ื นไขการทําซํ้า

จากขน้ั ตอนทง้ั 3 พิจารณาเปรียบเทียบกับคาํ ส่ัง for ดงั ตัวอยาง

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

…..

}

ในคําสง่ั for ดงั ตวั อยางมี i เปน คา ควบคมุ มีเงื่อนไขตรวจสอบคาควบคุม และมกี ารเปล่ยี นแปลงคา

ควบคมุ เพอื่ นาํ ไปสกู ารตรวจสอบเง่ือนไขอกี คร้งั ซึ่งสามารถเขียนในรูปแบบของคาํ สง่ั while ไดวา

56

i = 0;
while ( i < 10 ) {

…
i++;
}
จะเห็นวาคําสง่ั for นนั้ สามารถเขียนในรูปแบบของคาํ สัง่ while ไดเ ชน เดียวกัน ตางกันที่คาํ ส่ัง for มัก
จะใชก บั การทํางานที่รูจาํ นวนรอบของการทาํ ซํ้าทแ่ี นน อน สว นคาํ สัง่ while สามารถใชไดทั่วไปแตจะเหมาะกับ
งานทไ่ี มร จู าํ นวนรอบการทาํ ซํ้าดังตัวอยางขางตน ตัวอยางเพิ่มเติมแสดงดังตัวอยางที่ 3.13

ตวั อยางที่ 3.13 รบั ขอ มลู จาํ นวนเตม็ จากผูใช จนกวาผูใชจะปอนเลข -9999 ใหหาวามีเลขจาํ นวน
เตม็ ลบ (ไมร วม –9999) อยูกี่จาํ นวน และมีเลขจาํ นวนเต็มบวก (รวมทั้งเลขศูนย) อยูกี่จาํ นวน

#include <stdio.h>

void main( ) {
int countPlus, countMinus, num;
countPlus = countMinus = 0;
printf(“Enter number (-9999 for end) : “);
scanf(“%d”, &num);
while (num != -9999) {
if (num < 0)
countMinus++;
else
countPlus++;
printf(“Enter number (-9999 for end) : “);
scanf(“%d”, &num);
}
printf(“Number less than zero = %d, more than or equal to zero = %d”,
countMinus, countPlus);

}

ในกรณขี องการใชค าํ สง่ั วนซ้ําตาง ๆ สิ่งที่ตองระวังคือการนําเอาเลขจาํ นวนจริงมาเปนคาควบคุมกา
รวนซา้ํ พิจารณาจากตัวอยาง เนื่องจากเรารูวา 1/3 + 1/3 + 1/3 มคี า เทา กับ 1 เราจงึ จะใชวิธีการดังกลาวมา
เปน ตวั ควบคุมการทาํ งานวนซํา้ เชน

57

float x, y;
x = 1.0f;
y = 1/3;
while (x != y) {

printf(“\n55555”);
y += 1/3;
}

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

x = 1.0f;
y = (1/3) + (1/3) + (1/3);
if (x == y)

printf(“Equal”);
else

printf(“Not equal”);

คาํ ตอบที่ไดคือ Not equal เพราะฉะนนั้ หากใชเลขจํานวนจริงและการคาํ นวณเปนเปนสิ่งควบคุม กา
รวนซาํ้ หรอื นาํ ไปเปรยี บเทยี บเงอ่ื นไขจะตอ งระมดั ระวงั ในการเขยี นโปรแกรม แสดงตัวอยางเพิ่มเติมในตัวอยางที่
3.14 และ 3.15

ตวั อยา งที่ 3.14 เขยี นโปรแกรมเพื่อรับคาเลขจาํ นวนจริงจากผูใช 1 จํานวน และใหลบออกดวย
0.16523 อยากทราบวา จะตอ งลบออกกค่ี รง้ั เลขทร่ี บั เขา มานน้ั จงึ จะมคี า เขา ใกล 0 มากที่สุด (เขาใกลท างบวก)
และคาที่เขาใกล 0 นั้นมีคาเทาใด

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

int count=0;
float num, ;
printf(“Enter number : “);
scanf(“%f”, &num);
while (num > 0) {

num -= MINUS_VALUE;
count++;
}
printf(“It’s need %d times, value is %f”, count-1, num+MINUS_VALUE);
}

58

จากตวั อยางมีการใชคาํ สงั่ #define เปน การบอกใหรูวาหากเมื่อใดเจอขอความที่อยูตรงกลาง จะ
กาํ หนดใหมีคาเทากับคาที่อยูทางขวาสุด เชน #define MINUS_VALUE 0.16523 แปลไดวาเมื่อใดที่คาํ สั่งใน
โปรแกรมมีการอางถึงคาํ วา MINUS_VALUE ใหแ ทนที่ขอความนั้นดวย 0.16523 เพราะฉะนัน้ เมื่อพบคาํ ส่ัง

num -= MINUS_VALUE;
จะมีคาเทากับคาํ สงั่

num -= 0.16523;
ในตวั อยา งท่ี 3.14 เมื่อตองการพิมพทราบคาํ ตอบจะตองมีการเพิ่มคา num และลดคา count เนื่อง
จากในมกี ารทาํ วนซํา้ ตรวจสอบไววา num > 0 ตราบใดที่คา num มคี า มากกวา 0 จะทํางานไปเรื่อย ๆ และจะ
จบก็ตอมีคา num มคี า มากกวา หรอื เทา กบั 0 แตคําตอบตองการคา num ทเี่ ขา ใกล 0 ทางบวก เพราะฉะนนั้ จงึ
ตอ งมีการเพิ่มคาให num เปน สถานะกอนสุดทาย คือ บวกดวย MINUS_VALUE และลดคา count ลง 1

ตวั อยางที่ 3.15 โปรแกรมเพื่อรับคะแนนสอบของนักเรียนใหอยูในชวง 10 ถึง 20

#include <stdio.h>

#define YES 1
#define NO 0

void main( ) {
int num, correct=NO;

printf(“Enter number : “);
scanf(“%d”, &num);
while (!correct) {

if (num >= 10 && num <= 20)
correct = YES;

else {
printf(“Error data !!!!\n”);
printf(“Enter number : “);
scanf(“%d”, &num);

}
}
}

ในตวั อยางที่ 3.15 สามารถนาํ ไปประยุกตใชกับการตรวจสอบคาของขอมูลที่รับเขามาใหอยูในชวงที่
กาํ หนดไว ในที่นี้ใชตัวแปร correct เปน ตวั ควบคุมการวนซํา้ โดยกาํ หนดเริ่มตนใหเทากับ NO คอื 0 เมื่อตรวจ
สอบเงอ่ื นไข !correct จะไดคา 1 ทาํ ใหก ารวนซา้ํ เปน จรงิ จะเขา ไปทําคาํ สั่งใน while หากตรวจสอบไดวา

59

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

printf(“Enter number : “);
scanf(“%d”, &num);
while (num < 10 || num > 20) {

printf(“Error data !!!!\n”);
printf(“Enter number : “);
scanf(“%d”, &num);
}

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

ตวั อยา งที่ 3.16 โปรแกรมเพื่อรับขอมูลจากผูใช N คน โดยทผ่ี ใู ชแตล ะคนปอนเลขจํานวนเต็มเขาสู
ระบบไดต ามความพอใจจนกวาจะปอ นเลข 9999 ใหหาคาเฉลี่ยของเลขที่ผูใชแตละคนปอน และหาคาเฉลี่ย
ของเลขทป่ี อ นเขา สรู ะบบทงั้ หมด และหาวาผูใชแตละคนปอนเลขจํานวนเต็มที่อยูในชวง 0 ถึง 30 คนละกี่ตัว
และหาวา มกี ารปอ นเลขเลขจํานวนเต็มลบที่อยูในชวง –1 ถึง –30 กี่ตัวโดยผูใชทั้งหมดกี่ตัว

#include <stdio.h>
#include <conio.h>

void main() {
int n, num, countOne, countAll, countSpecOne, countSpecAll, i;
float sumOne, sumAll, averageOne, averageAll;
clrscr();
countAll = countSpecAll = 0;
sumAll = 0.0f;
printf("Enter N : ");
scanf("%d", &n);
for (i = 1; i <= n; i++) {
countOne = countSpecOne = 0;
sumOne = 0.0f;
printf("\n\nFor user no. %d\n", i);
printf("Enter number : ");
scanf("%d", &num);

60

while (num != 9999) {
countOne++;
sumOne = sumOne + num;
if (num >= 0 && num <= 30)
countSpecOne++;
else if (num <= -1 && num >= -30)
countSpecAll++;
printf("Enter number : ");
scanf("%d", &num);

}
averageOne = sumOne / countOne;
printf("Average for user no. %d is %.2f", i, averageOne);
printf("\nNumber of data between 0 and 30 is %d", countSpecOne);
countAll = countAll + countOne;
sumAll = sumAll + sumOne;
}
averageAll = sumAll / countAll;
printf("\n\nAverage for all user is %.2f", averageAll);
printf("\nNumber of data between -1 and -30 is %d", countSpecAll);
getch();
}

จากตวั อยา งสงิ่ ทตี่ องระวังคือการหาคาตัวนับตาง ๆ วา เปน ตวั นบั สาํ หรบั งานใด และสาํ หรับผใู ชแ ตล ะ
คนหรอื วา สาํ หรบั ขอ มลู ทง้ั หมด หากโปรแกรมซับซอนควรจะเริ่มจากการแกปญหายอย ๆ ทลี ะขอ โดยอาจจะ
แยกเปนขั้นตอนคือ

1. รบั ขอ มลู คา N คอื จาํ นวนผใู ชก อ น สรางการวนซํา้ สาํ หรบั การทาํ งานของผูใช N คน อาจจะใช
คาํ ส่งั for หรอื คําสัง่ while ก็ได

2. พจิ ารณาการทาํ งานของผูใชแตละคน รบั ขอมลู ของผูใชแ ตละคน ซึ่งตองรับขอมูลจนกวาจะปอน
เลข 9999 จึงจะหยุดการทํางาน ซึ่งสามารถใชคําสง่ั while มาชว ยในการทาํ งาน

3. แกป ญ หาทโี่ จทยตอ งการทีละอยาง โดยอาจจะเริ่มจากหาคาเฉลี่ยของผูใชแตละคน
4. หาคา เฉลี่ยของผูใชทั้งหมด
5. หาคา ที่อยูในชวง 0 ถึง 30 สาํ หรับผูใชแตละคน
6. หาคา ที่อยูในชวง –1 ถึง 30 สําหรบั ผูใชท้งั
การแบง งานเปนปญ หายอ ยแลว แกป ญ หายอ ยเหลา นน้ั จะชว ยใหก ารเขยี นโปรแกรมทาํ ไดงายขึ้น ซึ่ง
เปน หลักการของการแบงแยกและเอาชนะ (Divide and Conquer) ซง่ึ ใชท ั่วไปในงานเขียนโปรแกรม และ
สามารถเขยี นเปนงานยอยซึ่งจะกลาวถึงในบทที่ 4 เรื่องของฟงกชันตอไป

61

5. คาํ สง่ั do-while
คาํ ส่งั do-while เปน คาํ สั่งวนซาํ้ อกี รปู แบบหนง่ึ แสดงผงั งานดังรูปที่ 3.4

รปู ท่ี 3.4 แสดงผงั งานของการทํางานคําสัง่ do-while
จากรปู จะเห็นวาการทาํ งานของคาํ ส่ัง do-while จะตอ งมีการทาํ งานคําสั่ง1 และคาํ สงั่ 2 เสมอ หลงั
จากนนั้ จะมกี ารตรวจสอบเงื่อนไข หากเงอ่ื นไขเปน จรงิ กจ็ ะกลบั ไปทําคาํ สั่งใน do-while อกี จนกวาเงื่อนไขนั้น
จะเปนเท็จ เขยี นในรปู แบบของคาํ สั่งไดวา

do {
คาํ สั่ง1 ;
คําสง่ั 2 ;

} while ( เงื่อนไข ) ;

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

do {
printf(“Enter number (between 10 and 20) : “);
scanf(“%d”, &num);

} while (num < 10 || num > 20);
จากตวั อยา งจะมกี ารรับขอ มูล แลวตรวจสอบวาขอมูลอยูนอกชวงที่กําหนด คือ นอยกวา 10 หรือมาก
กวา 20 ถอื วาขอมูลไมถูกตองใหไปรับขอมูลใหมจนกวาจะถูกตอง พิจารณาตัวอยางที่ 3.17 และ 3.18

62

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

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

int num, count=0;
float sum=0.0f, average;
do {

printf(“Enter number : “):
scanf(“%d”, &num);
if (num != 9999) {

count++;
sum += num;
}
} while (num != 9999);
average = sum / count;
printf(“Average is %.2f”, average);
}

ตวั อยางที่ 3.18 รบั ขอ มลู จาํ นวนเต็มจากผูใช จะหยุดรับขอมูลเมื่อผลรวมของขอมูลนั้นมีคามากกวา
200 ใหห าวา มกี ารรบั ขอ มลู ทง้ั หมดกจ่ี ํานวน

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

int num, sum=0, count=0;
do {

printf(“Enter number : “):
scanf(“%d”, &num);
sum += num;
count++;
} while (sum <= 200);
printf(“Enter number %d times”, count);
}

คําส่ัง do-while สามารถนาํ ไปประยุกตใชไดเหมือนกับคาํ สง่ั while หรอื for แตม กั จะใชค ําสั่งนี้ในการ
ตรวจสอบความถกู ตอ งของขอ มลู หรือใชในการสั่งใหโปรแกรมทํางานวนซํา้ จนกวาผูใชตองการใหหยุดการ

63

ทาํ งาน จากตวั อยา งที่ไดแสดงมาทั้งหมดจะเห็นวาเปนการทาํ งานเพียงครั้งเดียวก็จบการทํางานของโปรแกรม
หากตอ งการทาํ งานนั้นอีกครั้ง ก็จะตองเรียกใชงานโปรแกรมนั้นใหม สามารถใชคาํ สง่ั do-while มาชวยไดดัง
ตวั อยางที่ 3.19

ตวั อยา งที่ 3.19 รบั ขอ มลู จาํ นวนเต็มจากผูใช จะหยุดรับขอมูลเมื่อผลรวมของขอมูลนั้นมีคามากกวา
200 ใหห าวา มกี ารรบั ขอ มลู ทง้ั หมดกจ่ี ํานวน เมื่อโปรแกรมทํางานเสรจ็ ใหท ํางานวนรบั ขอมูลตอไป โดยขน้ึ ขอ
ความสอบถามวา Exit program (Y/N) ? หากผูใชปอนขอมูล y หรอื Y ใหห ยุดการทาํ งานของโปรแกรม แตถา
ปอ นขอ มลู อน่ื ๆ ใหเรียกโปรแกรมเดิมกลับมาทาํ งานอีกครั้ง

#include <stdio.h>

void main( ) {
int num, sum=0, count=0;
char ch;
do {

do {
printf(“Enter number : “):
scanf(“%d”, &num); flushall( );
sum += num;
count++;

} while (sum <= 200);
printf(“Enter number %d times”, count);

printf(“\n\nExit program (Y/N) ? “);
scanf(“%c”, &ch);
} while (ch == ‘y’ || ch == ‘Y’);
}

64

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

1. หาทผี่ ดิ ของคําสงั่ ตอไปน้แี ละแกไ ขใหถกู ตอ ง (ขอ นี้ใหหาเฉพาะที่ผิดพลาด) .
(ก) IF a = 0 .
(ข) if (a>0 and a<20) or (10<=b<=40)) (ก) เมื่อ sex มีคา ‘M’ และ age มคี า 50 .
a=a+b (ข) เมื่อ sex มีคา ‘M’ และ age มคี า 80 .
else c > 50; (ค) เมือ่ sex มีคา ‘M’ และ age มคี า 25 .
a=a+c (ง) เมื่อ sex มีคา ‘F’ และ age มคี า 50 .
(ค) if (b = 20 && b <>a); (จ) เม่ือ sex มีคา ‘F’ และ age มคี า 80 .
a += b; (ง) เมื่อ sex มีคา ‘U’ และ age มคี า 30 .
b = b + 1; .
if else (b < 10) .
b = b + 2;
(ง) switch (a=4) ; .
case 10-20 : a = 10; .
break; .
case > 30 : a = 20; .
case b : a = 30; .
default : a = 40; .
(จ) for (i=5; i=10; i+1); .
(ฉ) while (i=5); .
a = a + 5; .
b = a * 2; .
(ช) i = 5; .
do .
printf(“%d\n” i) .
while (i++ <> 10);

2. หาผลลพั ธก ารทาํ งานของคาํ สง่ั ตอ ไปน้ี
if (sex == ‘M’ && age > 40) {
printf(“\n11111”);
if (age > 60)
printf(“\n22222”);
} else if (sex == ‘F’)
printf(“\n33333”);
else
printf(“\n44444”);

65

3. หาจํานวนรอบที่ทาํ งาน คา i สดุ ทายในลูป และคา i เมอ่ื ทาํ งานจบลปู (จบการทาํ งานวนรอบ) ตอ ไปน้ี

จาํ นวนรอบที่ทาํ งาน คา i สดุ ทายในลูป คา i เมอ่ื จบลปู

(ก) for (i=0; i <10; i++) . ..

(ข) for (i=0; i <100; i++) . ..

(ค) for (i=50; i>0; i-=2) . ..

(ง) for (i=10; i+5<100; i*=2) . ..

4. หาผลลพั ธข องการทาํ งานตอไปน้ี (ข) for (i=0; i<10; i+=2) {
(ก) for (i=0; i<10; i++) printf(“\n11111”);
printf(“\n11111”); if (a >= 5)
printf(“\n22222”); printf(“\n22222”);

(ค) for (i=0; i < 10; i++) { }
printf(“\n11111”); (ง) for (i=0, j=5; i<10 && j < 20; i++, j+=3) {
printf(“\n22222”);
printf(“\n11111”);
} if (i > 4 && j > 10)

printf(“\n22222”);
else if (i > 8)

printf(“\n33333”);
if (j > 15)

printf(“\n44444”);
}

5. แปลงคาํ สั่ง switch ตอ ไปนเ้ี ปน คาํ ส่ัง if-else และหาผลลพั ธข องการทาํ งาน

switch (a) { (ก) เมื่อ a = 0

case 5 : a = 3; (ข) เมื่อ a = 5

break; (ค) เมื่อ a = 10

case 10 : a = 5; (ง) เมื่อ a = 15

case 15 : b = a; (จ) เมื่อ a = 18

break; (ฉ) เมื่อ a = 20

case 20 : a = 10; (ช) เมื่อ a = 40

break;

default : a = b;

b = 0;

}

66

6. แปลงคาํ สง่ั if-else ตอ ไปนเ้ี ปน คาํ ส่งั switch (ข) j = k = 0;
if (a == 0) while (j + k < 20) {
a = 10; j += 2;
else if (a == 5) { k++;
x = a + b; }
if (b == 10)
a = b; .
} else if (a == 10 || a == 11 || a == 12) {
a = a * 2;
b = b / 2;
} else
a = 0;

7. แปลงคาํ สั่ง for เปน คําส่ัง while
(ก) for (i = 10; i < 20; i++)
(ข) for (k = 0, m = 10; k < 10; k+=2, m*=2)
(ค) for (j=-10; j < 0 || j+3 <1; j+=2)
(ง) for (i = 0; i < 50 && i *2 > 60; i += 4)

8. แปลงคาํ สง่ั while เปนคําสง่ั for
(ก) i = 20;
while (i < 100 && i * 2 < 140) {
…..
i *= 2;
}
.

9. จดั รูปแบบการเยื้อง (Indentation) ใหเ หมาะสม
(ก) if (a > 0 && b > 0) a = a + 2; else if (a > 50) a = 10; else if (b < 20 || a < -15) { a = b;
b = b *2; }else {a = 5; b = 10;}
(ข) switch ( x ) { case 10 : a = 5; b= 4; break; case 20 : case 30 : case 40 : a = 10; break; case
50 : a = b; break; default : b = a; a = 12; }
(ค) for(i=0; i < 15; i++) { a = a + b; b = 15; c = a * 2; if (a >= 15) { x = x + 10; } else { y++; c++;
} d = x + y + c; }

10. เขยี นโปรแกรมเพอ่ื รบั คา ขอ มลู จาํ นวนเต็มจากผูใช ใหหาวาถาเพิ่มคาขอมูลนั้นขึ้น 2 เทาจะมีคาเทาใด
11. เขยี นโปรแกรมเพอ่ื คาํ นวณยอดภาษี VAT โดยคิดภาษี VAT ท่ี 7 % ใหร บั ขอ มลู ยอดเงนิ ทล่ี กู คา ซอ้ื สนิ คา

และแสดงยอดภาษี และยอดเงินที่ลูกคาตองจายทั้งหมด

67

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

13. เขยี นโปรแกรมเพอ่ื คาํ นวณการทอนเงินใหกับลูกคา โดยรับขอมูลยอดซื้อของลูกคา และยอดเงินที่ลูกคา
จา ย ใหค าํ นวณวาตองทอนเงินใหกับลูกคาเปนแบงก 1000 500 100 50 20 และเหรยี ญ 10 5 และ 1
บาทจาํ นวนอยา งละเทา ใด (กาํ หนดวาไมมีการทอนเงินเปนเศษสตางค)

14. เขยี นโปรแกรมเพื่อรับขอมูลตัวอักษรจากผูใช หากผูใชปอนตัวอักษร a, b, x ใหขึ้นขอความวา “Hanaga”
ปอ นตัวอักษร u, d, p ใหขึ้นขอความวา “Bingo” ปอ นตัวอักษร g ใหข ึ้นขอความวา “Google” ปอนตวั
อกั ษรอน่ื ๆ ใหขึ้นขอความวา “Yappadappadoooo” โดยใชคําสง่ั if-else

15. เขยี นโปรแกรมเพอ่ื รบั ขอ มลู เลขจาํ นวนจริง 3 คาจากผูใช และพิมพคาดังกลาวเรียงจากมากไปนอย
16. เขยี นโปรแกรมเพื่อตรวจสอบป ค.ศ. ท่ีรบั จากผใู ชเ พ่ือตรวจสอบวาเปนปอธิกสุรทนิ หรอื ไม โดยทป่ี อ ธกิ สรุ

ทนิ เปน ปที่หารดวย 4 ลงตวั กรณที เ่ี ปน ปท เ่ี ปน ศตวรรษจะตอ งหารดว ย 400 ลงตวั เชน (ป ค.ศ.1900 ไมเปน
ปอ ธกิ สรุ ทนิ แมจะหารดวย 4 ลงตัว แตป ค.ศ. 2000 เปน ปอ ธกิ สรุ ทนิ )
17. เขยี นโปรแกรมเพอ่ื ชว ยในการแปลงหนว ยการวดั โดยมีอัตราสวนคือ 1 นิ้วเทากับ 2.54 เซนติเมตร ใหผูใช
ระบวุ ธิ กี ารแปลงคาและเลขที่ตองการแปลงคา ถาปอนวิธีการแปลงคาเปน I จะแปลงขอมูลจากเซนติเมตร
เปน นว้ิ ถาปอนวิธีการแปลงคาเปน C จะแปลงขอมูลจากนิ้วเปนเซนติเมตร หากปอ นขอ มลู วธิ กี ารแปลง
เปน คา อนื่ หรอื ตัวเลขที่ตองการแปลงคามีคาติดลบ ใหขึ้นขอความแสดงความผดิ พลาดที่เกิดขึ้น
18. อนุกรมของเลขชุดหนึ่ง คือ 1, 2, 3, 5, 8, 13, … โดยตวั เลขถัดมาเกิดจากคาผลบวกของ 2 เทอมที่อยูกอน
หนา จงเขียนโปรแกรมโดยใชคําสั่ง for เพอื่ รบั ขอมูลเลขเริ่มตน 2 เทอมแรก และจํานวนเทอมที่ตองการทั้ง
หมด และใหแสดงผลอนุกรมดังกลา ว
19. เขยี นโปรแกรมเพอ่ื บวกเลขจาํ นวนเต็ม N จาํ นวน โดยรับคา N จากผูใช
20. เขยี นโปรแกรมเพอ่ื บวกเลขจาํ นวนเต็มคี่ N จํานวน โดยรับคา N จากผูใช
21. เขยี นโปรแกรมเพื่อรับขอมูลความสูงและอายุของผูใชจาํ นวน 50 คน ใหนับวามีผูที่อายุมากกวา 15 ปแ ละ
ความสงู ตง้ั แต 175 เซนติเมตรขึ้นไปมีกี่คน และผูที่อายุมากกวา 20 ป ที่มีความสูงตั้งแต 180 เซนติเมตรขึ้น
ไปกค่ี น และใหหาอายุเฉลี่ยและความสูงเฉลี่ยของขอมูลที่ปอนเขามาทั้งหมด
22. เขยี นโปรแกรมโดยใชคําสง่ั for เพอื่ คาํ นวณราคาสนิ คา โดยใหผูใชป อนจาํ นวนรายการของสนิ คาที่
ตอ งการคาํ นวณ และปอนรายละเอียดของแตละรายการประกอบดวย ราคาตอหนวยและจํานวนหนว ย
ของสนิ คา ใหคาํ นวณ

- ราคาสินคาทั้งหมด
- รา นคา มขี อ กาํ หนดการลดราคาวา หากซื้อตั้งแต 5,000 บาท ลดราคา 3 % ถา ซื้อตั้งแต 40,000

บาท ลดราคา 4% และซอ้ื เกิน 100,000 บาท ลดราคา 5 % ใหค าํ นวณยอดเงินของการลดราคา
และยอดเงินที่ลูกคาตองชาํ ระหลังจากลดราคาแลว
23. เขยี นโปรแกรมเพื่อตรวจสอบวาเลขจาํ นวนเต็ม N ทรี่ บั จากผูใชเปน Prime Number หรอื ไม โดย Prime
Number คอื เลขจาํ นวนเต็มบวกที่มากกวา 1 ซึ่งมีแตเลข 1 และตัวมันเองเทานั้นที่หารไดลงตัว

68

24. เขยี นโปรแกรมโดยใชคําสัง่ while เพอ่ื คาํ นวณราคาสนิ คา โดยใหผ ูใ ชป อ นจาํ นวนรายการของสนิ คาท่ี
ตอ งการคาํ นวณ และปอนรายละเอียดของแตละรายการประกอบดวย ราคาตอหนวยและจํานวนหนว ย
ของสินคา ใหคาํ นวณ
- ราคาสินคาทั้งหมด
- รา นคา มขี อ กาํ หนดการลดราคาวา ยอดเงิน 10,000 บาทแรกลดราคาให 2 % ยอดเงนิ ท่ีเกนิ กวา
10,000 บาท แตไมเกิน 50,000 บาทลดราคาให 3 % ยอดเงนิ ที่เกินกวานั้นจะลดราคาให 4 %
ใหค าํ นวณยอดเงินของการลดราคา และยอดเงินที่ลูกคาตองชาํ ระหลังจากลดราคาแลว

25. ปรบั ปรงุ โปรแกรมในขอ 15 ใชคําสัง่ while เชน เดมิ โดยไมมีการปอนจาํ นวนรายการของสินคาที่ตองการ
คาํ นวณ แตถ าเมื่อใดที่ผูใชปอนราคาตอหนวยของสินคามีคาติดลบหรือเปนศูนย แสดงวาเปนจุดสิ้นสุด
ของการปอนรายการสินคา

26. ปรบั ปรงุ โปรแกรมในขอ 12 โดยมีการทาํ งานวนซํา้ เพื่อรับขอมูลใหม เมื่อทํางานเสร็จแตละรอบใหข ึ้นขอ
ความวา “Continue program (Y/N) ?“ หากผูใชตอบ Y ใหท าํ งานแปลงขอมูลใหม แตถ าปอนขอมลู อ่ืน ๆ
ใหจ บการทํางานของโปรแกรม

27. เขยี นโปรแกรมโดยใชคําสั่ง do-while เพอื่ รบั ขอ มูลความสูงของสมาชิกชมรมบาสเก็ตบอลที่ผูใชปอนเขาสู
ระบบ ตราบใดที่ปริมาณความสูงเฉลี่ยสะสมยังไมเกิน 175 เซนติเมตร และยังมีขอมูลสมาชิกไมเกิน 5 คน
ใหร บั ขอ มลู ไปเรอื่ ย ๆ ใหหาวามีการรับขอมูลทั้งหมดกี่จาํ นวน และความสงู เฉลย่ี สะสมสดุ ทา ยมคี า เทา ใด

28. เขยี นโปรแกรมเพอ่ื รบั ขอ มลู คะแนนรวมของนกั ศกึ ษาในกระบวนวชิ าหนง่ึ ซึ่งมีไมเกิน 80 คน หากเมื่อใดที่
ปอ นคะแนนตดิ ลบ แสดงวาสิ้นสุดการปอนขอมูล ใหหาจํานวนนักศึกษาที่ไดเกรดไดระดับตาง ๆ วามี
จาํ นวนกค่ี น โดยมีขอกาํ หนดวา
คะแนน เกรด
ตํ่ากวา 50 F
50-59 D
60-69 C
70-79 B
80 ขน้ึ ไป A

ฟง กช นั

( Functions ) 4

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

โปรแกรมภาษาซีจะประกอบขึ้นจากฟงกชันหลาย ๆ ฟงกชันอยูในแฟมตนฉบับ (Source File) ตง้ั แตห นง่ึ แฟม ขน้ึ ไป
หลงั จากนั้นจะนําแฟม เหลา นไ้ี ปทําการแปลโปรแกรม (Compile) เพอื่ ใหไดแฟมจุดหมาย (Object File) และเชื่อม (Link) เขา
ดว ยกนั และอาจจะมีการเชื่อมเขากับคลังโปรแกรม (Library File) หากมกี ารเรียกใชฟงกชันอื่น ๆ จากคลังโปรแกรม คลัง
โปรแกรมเปน แฟม จุดหมายที่เก็บฟงกชันยอยที่สามารถเรียกใชไดโดยโปรแกรมใด ๆ ชวยใหประหยัดเวลาในการพัฒนา
โปรแกรมไดเ ปน อยางมาก เชน หากมกี ารใชฟ ง กชันใดบอ ยในหลาย ๆ โปรแกรม หรือหากจะตองเขียนฟงกชันนั้นในทุก
โปรแกรมทเี่ รยี กใชจะเปนการเสยี เวลาพัฒนาโปรแกรม ก็สามารถนําฟง กชนั น้นั ไปเกบ็ ไวใ นคลังโปรแกรมเพอื่ ใหโ ปรแกรมอื่น
เรียกใชได

compile link Library file
link
Source file Object file

Execute file

link

compile

Source file Object file

รปู ท่ี 4.1 แสดงขั้นตอนการแปลโปรแกรมภาษาซี

1. แนวความคิดในการออกแบบฟงกชัน

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

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

70

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

• ขอ มลู เขา หมายถึงขอมูลที่จําเปน ตอ งทราบกอ นการประมวลผลฟง กช นั นน้ั โดยฟงกชันที่ออกคาํ ส่ัง
จะเปน ผใู หข อ มลู แกฟ ง กช นั ทไ่ี ดร บั คําสั่งใหทาํ งาน

• ขอ มลู ออก หมายถงึ ขอ มูลทไ่ี ดจ ากการประมวลผลของฟง กช นั เมื่อฟงกชันที่ไดรับคาํ สง่ั ทํางานเสร็จ
จะสง คา ขอ มลู นก้ี ลบั ไปใหก บั ฟง กช นั ทอ่ี อกคําสงั่

เนอื่ งจากภาษาซีมีการสงอารกิวเมนท (argument) ใหก บั ฟง กช นั แบบ By Value และฟงกชันสามารถคืนคา
(return) คา ไดเ พยี งหนง่ึ คา ซึ่งสามารถอธิบายไดดังนี้

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

• เม่ือฟงกชันที่ไดรับคําส่ังทํางานเสร็จจะสามารถสงคาขอมูลกลับใหแกฟงกชันท่ีออกคําสั่งไดเพียง
หนงึ่ คาเทานั้น หรืออาจไมสงขอ มูดกลับเลยก็สามารถทาํ ได

ตวั อยางที่ 4.1 การออกแบบโปรแกรมการบวกเลขจาํ นวนจริง 2 จํานวนที่รับจากผูใช และแสดงผลลพั ธท ไ่ี ดจ าก
การคาํ นวณ

วเิ คราะหการทาํ งานของโปรแกรม วธิ ปี ระมวลผล ขอ มลู ออก
ขอมูลเขา
• หาผลรวมของเลข 2 • ผลลัพธจากการบวกเลข
• ตัวเลข 2 จาํ นวน จํานวน 2 จํานวน

ในการออกแบบโปรแกรมน้ี สามารถแบงออกเปนงานยอย ๆ ดังนี้
• รบั ขอ มลู 2 จํานวนจากผูใช
• บวกเลข 2 จํานวนแลว เกบ็ ผลลพั ธ
• แสดงผลลพั ธข องการทาํ งาน

จากการแบง การทาํ งานออกเปนงานยอยๆ และขอควรคาํ นึงที่ระบุขางตน เราสามารออกแบบโปรแกรมนโ้ี ดยแบง
การทาํ งานออกเปน 3 ฟงกชันยอย และ 1 ฟงกชนั หลกั โดยที่ 3 ฟงกชันยอยดังกลาวไดแก

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

2. ฟง กช นั บวกเลข ทาํ หนาที่บวกเลขจาํ นวนจริง 2 จํานวน และสงคาขอมูลที่ไดจากการคํานวณกลับ
มาใหฟงกชันหลัก

3. ฟง กช นั แสดงผล ทาํ หนา ทแ่ี สดงผลลพั ธจ ากการคํานวณ

71

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

start ฟง กชันรับขอมูล
print "Input real value: " ฟง กชันรับขอมูล

read a1 ฟง กชันบวกเลข
print "Input real value: " ฟงกชันแสดงผล

read a2

sumVal = a1 + a2

print "Result of sum is:"
,sumVal
end

ในการออกแบบฟง กช นั ยอ ยสามารถใชว ิธอี อกแบบแบบกลอ งดํา (Black Box Design) การออกแบบในลกั ษณะน้ี
จะคดิ จากหนา ทข่ี องฟง กช นั นน้ั เปน หลกั และพิจารณาวาจะตองมีขอมูลเขาสูฟงกชันและขอมูลที่จะสงกลับเมื่อจบฟงกชัน
คอื อะไร ดังรูปท่ี 4.2

ขอ มูลเขาสูฟงกชัน ขอมูลที่สงกลับเมื่อจบฟงกชัน

รปู ท่ี 4.2 การออกแบบฟงกชันแบบกลองดาํ

จากตวั อยา ง 4.1 เราสามารถออกแบบแตละฟงกชันยอยทั้ง 3 ฟงกชันแบบกลองดาํ ไดดังนี้

ฟง กชันรับขอมูล
ทาํ หนา ทร่ี บั ขอ มลู จํานวนจริง 1 จํานวนจากผูใช เมื่อทํางานเสร็จจะทาํ การสงคาจาํ นวนจริงที่รับจากผูใชกลับไปยัง

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

72

ฟงกชัน จาํ นวนจริง 1 จํานวน
รบั ขอ มลู

รปู ท่ี 4.3 แสดงกลองดําของฟงกชันรับขอมูล

ฟง กชันบวกเลข
ฟง กช นั บวกเลขมหี นาที่ในการบวกเลข 2 จํานวน พิจารณาขอมูลเขาสูฟงกชันจะไดวาในการบวกเลขจะตองมีการ

รบั ขอ มลู จาํ นวน 2 จํานวนเขาสูฟงกชันเพื่อนํามาบวกกัน และคนื คาผลลพั ธข องการบวกนน้ั กลบั ไปยังฟง กชนั ทอ่ี อกคาํ สั่งให
ฟง กช นั บวกเลขทํางาน ซงึ่ ในที่นี้คือฟงกชัน main( ) ซงึ่ ผลลัพธของการบวกนั้นคือขอมูลที่ออกจากฟงกชัน การออกแบบ
ฟง กชันบวกเลขแสดงดังรูปที่ 4.4

จาํ นวนจริงจาํ นวนแรก ฟงกชัน ผลลพั ธข องการบวก
จาํ นวนจริงจาํ นวนที่สอง บวกเลข

รปู ท่ี 4.4 แสดงกลองดําของฟงกชันบวกเลข

ฟงกชันแสดงผล
ฟง กช นั แสดงผลมหี นา ทแ่ี สดงผลลพั ธอ อกทางจอภาพ พิจารณาขอมูลเขาสูฟงกชันจะไดวาขอมูลที่ตองการแสดง

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

ตวั เลขที่ตอ งการแสดงผล ฟงกชัน
แสดงผล

รปู ท่ี 4.5 แสดงกลองดําของฟงกชันแสดงผล

73

2. รปู แบบของฟง กช นั

การเขยี นฟง กชันในภาษาซีสามารถแบง การเขียนออกเปน 2 แบบหลักตามลักษณะการเขียน คือ
1. ฟง กช ันที่มีการสงคากลับเมื่อทํางานเสร็จ
2. ฟง กช ันที่ไมมีการสงคากลับเมื่อทํางานเสร็จ

2.1 ฟง กช นั ที่มีการสงคากลับเมื่อทาํ งานเสร็จ
ฟง กช นั ทม่ี กี ารสง คากลับเมือ่ ทาํ งานเสร็จนี้เปนฟงกชันที่จะตองมีการสงคากลับไปยังฟงกชันที่เรียกใชงานฟงกชันนี้
เมอ่ื ทาํ งานเสรจ็

ขอ มลู เขา ขอ มลู ออก

รปู ท่ี 4.6 แสดงกลองดาํ ของรูปแบบฟงกชันที่มีการสงคากลับเมื่อทํางานเสร็จ

รปู แบบฟง กชันที่มีการสงคากลับเมื่อทํางานเสร็จมีลักษณะดังนี้

ชนดิ ขอ มลู ทค่ี นื คา ชอื่ ฟงกชัน ( การประกาศตัวแปรที่จะรับคาจากฟง กชันอื่นที่เรียกใชฟงกชันนี้ )
{

การประกาศตัวแปรภายในฟงกชัน;
คําสง่ั ;
return(คา ขอ มลู ทต่ี อ งการสง คา กลบั );
}

จากรูปแบบของฟงกชันขางตน ชนดิ ของขอ มูลท่ีคนื คา จะเปนประเภทขอมูลชนิดใด ๆ เชน int float float char
เปน ตน กอนจบฟงกชันจะตองมีการสงคากลับดวยคําสั่ง return แลว ตามดวยคาที่คืนกลับซึ่งเปนขอมูลชนิดเดียวกับ ชนิด
ของขอมูลที่คืนคา

74
2.2 ฟง กช นั ที่ไมมีการสงคากลับเมื่อทาํ งานเสร็จ
ฟง กช นั ทไี่ มม กี ารสงคากลับเมอื่ ทํางานเสร็จ จะเปนฟงกชันที่เมื่อทํางานในฟงกชันเสร็จก็จะคืนการทาํ งานกลับไป
ยงั ฟง กช ันที่เรียกใชงานโดยที่ไมมีการคืนคาใด ๆ กลับไป

ขอมูลเขา

รปู ท่ี 4.7 แสดงกลองดาํ ของรูปแบบฟงกชันที่ไมมีการสงคากลับเมื่อทํางานเสรจ็

รปู แบบฟง กชันที่ไมมีการสงคากลบั เมื่อทํางานเสร็จมีลักษณะดังนี้

void ชื่อฟงกชัน ( การประกาศตัวแปรที่จะรับคาจากฟง กชันอื่นที่เรียกใชฟงกชันนี้ )
{

การประกาศตัวแปรภายในฟงกชัน;
คาํ สง่ั ;
}

จากรปู แบบของการประกาศฟงกชันที่ไมมีการสงคากลบั จะขึ้นตนดวยคําวา void และไมมีคําสั่ง return กอนจะ
จบการทํางานของฟงกชัน

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

#include <stdio.h>
float InputFloat ( ) {

float x;
printf ( “\nInput real value : “ );
scanf ( “%f”, &x );
return ( x );
}
float SumFloat ( float x, float y ) {
return ( x + y );
}

75

void PrintOut ( float x ) {
printf ( “\n Result of sum is : %.2f”, x );

}
void main ( ) {

float a1, a2, sumVal;
a1 = InputFloat( );
a2 = InputFloat( );
sumVal = SumFloat ( a1, a2 );
PrintOut ( sumVal );
}

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

การทาํ งานเริ่มจากคาํ สั่งแรก #include <stdio.h> เปนการเรียกใชอินคลชู ไฟล (Include File) เมื่อโปรแกรมมีการ
เรยี กใชง านฟง กช ันจากคลังโปรแกรม ซึ่งอาจจะเปนแฟมจากคลังโปรแกรมมาตรฐานที่ผูผลิตคอมไพเลอรเตรียมไว หรอื แฟม
จากคลงั โปรแกรมทผ่ี พู ฒั นาโปรแกรมจดั ทําขึ้นเอง จะทําการเรียกใชแฟมที่เก็บฟงกชันที่ตองการในคลังโปรแกรม ในที่นี้มี
การเรยี กใชฟ งกชันที่เกี่ยวของกับการรับขอมูลจากผูใชและแสดงผลขอมูลทางอุปกรณแสดงผล ไดแ ก scanf และ printf จึงมี
การเรยี กใชแฟมที่เก็บฟงกชันที่เกี่ยวของกับอุปกรณรับและแสดงผลมาตรฐาน คือ stdio.h กรณที เ่ี ปน แฟม โปรแกรมมาตร
ฐานจะเกบ็ ไวในสารบบ (directory) ทผี่ ผู ลติ คอมไพเลอรจัดเตรียมไว จะใชคําสง่ั

include <stdio.h>
แตห ากเปนแฟมที่รวบรวมฟงกชันที่ผูเขียนโปรแกรมสรางขึ้นเองจะใชคําสัง่

include “myfile.h”
หากไมมีการระบุสารบบ โปรแกรมจะคนหาแฟม myfile.h ทส่ี ารบบทท่ี ํางานปจ จบุ นั แตผูเขียนโปรแกรมสามารถ
ระบสุ ารบบไวในเครอ่ื งหมาย “ “ ไดเ ชน เดยี วกัน แฟมที่รวบรวมฟงกชันที่ผูเขียนโปรแกรมสรางขึ้นเองนี้จะปนแฟมขอความ
ธรรมดาทส่ี ามารถเปด อา นได เก็บขอมูลที่จําเปนตองใชในการเรียกใชฟงกชัน เชน การประกาศตัวแปร การประกาศโปรโต
ไทปของฟงกชัน เปนตน

จากนน้ั การทาํ งานของโปรแกรมจะเริ่มจากฟงกชันหลักคือ ฟงกชัน main( ) ภายในฟงกชัน main( ) หากมีการ
เรยี กใชฟ ง กช นั ยอ ยใด ก็จะมีสง การทํางานไปยังฟงกชันยอยนั้น ๆ เมื่อฟงกชันยอยนั้นทํางานเสร็จก็จะคืนการทาํ งานกลับ
มายังฟงกชัน main( ) ทาํ เชนนี้จนกระทั่งหมดคาํ สั่งในฟงกชัน main( ) ลาํ ดบั ของการเรียกใชงานฟงกชันยอยมีดังนี้

1. เรยี กฟงกชันรับขอมูล เพอ่ื รบั ขอ มลู ตวั แรก
2. เรยี กฟงกชันรับขอมูล เพอ่ื รบั ขอ มลู ตวั ทส่ี อง
3. เรยี กฟงกชันบวกเลข เพอ่ื ทําการคาํ นวณ
4. เรยี กฟง กช ันแสดงผล เพอ่ื แสดงผลลพั ธจ ากการคาํ นวณ

76

ขน้ั ตอนท่ี 1 และ 2 เปน ขนั้ ตอนของการรับขอมูลเขาเพื่อประมวลผล การทาํ งานทั้งสองขั้นตอนนี้ฟงกชันหลักจะ

ทาํ การเรยี กใชง านฟง กช นั รบั ขอ มลู ซึ่งเปนฟงกชันที่มีการคืนคากลับเปนจาํ นวนจริง 1 จํานวน ฟงกชันรับขอมูลมีการ

ประกาศหัวของฟงกชันรูปแบบดังนี้คือ

float InputFloat ( );

ในฟง กช นั หลกั หรอื ฟง กช นั main( ) จะตอ งมกี ารรบั ขอ มูลจํานวนจริง 2 คา เพราะฉะนั้นจะตองมีการเรียกใชงาน

ฟง กช นั นี้ 2 คร้งั ดังขั้นตอนที่ 1 และ 2 ขางตน เนื่องจากฟงกชันนี้มีการคืนคาเปนจาํ นวนจริงแบบ float ภายในฟงกชัน

main( ) จะตอ งมีตัวแปรแบบ float เพอื่ มารบั คา ดังกลาว การเรียกใชฟงกชันนี้สามารถใชคําสั่ง

float a1, a2; // ตวั แปรที่ใชรับคาการรับขอมูลจากผูใช

a1 = InputFloat( );

a2 = InputFloat( );

พจิ ารณาจากการเรยี กใชง าน หากฟงกชันใดมีการสงคากลบั ไปยังฟงกชันที่เรียกใช การเรียกใชจะตองมีตัวแปรที่

มชี นดิ เดยี วกบั ขอ มูลที่สงคืนจากฟงกชันยอยมารับคาเสมอ จากในตัวอยางฟงกชัน InputFloat( ) มกี ารคนื คา เปน แบบ float

เพราะฉะนั้นตัวแปรที่มารับคาจะเปนตัวแปรประเภทเดียวกัน ในที่นี้คือ a1 เปน ตวั แปรประเภท float จะถกู กาํ หนดใหมีคา

เทา กบั คาที่สงคืนมาจากฟงกชัน InputFloat( ) ในทน่ี ม้ี กี ารรบั คา จํานวนจริง 2 จํานวนจากผูใช เพราะฉะนั้นจะตองมีการ

เรยี กใชฟงกชัน InputFloat( ) 2 คร้งั ครงั้ แรกเก็บคาที่ผูใชปอนในตัวแปร a1 และเมอื่ มีการเรียกใชครั้งที่ 2 คาที่ไดจะเก็บไว

ในตัวแปร a2

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

float SumFloat ( float, float );
เมอื่ ตอ งการเรยี กใชงานฟงกชันยอยดังกลาวจะตองมีการสงคาเขาไป 2 คา ในที่นี้คือ a1 และ a2 ทรี่ ับจากผูใช มี
ชนิดขอมูลเปน float และเมื่อฟงกชัน SumFloat( ) ทาํ งานเสร็จจะมีการสงคากลับจึงตองมีตัวแปรชนิด float อกี 1 ตัวมารับ
คา ผลบวกดงั กลาว จะเรียกใชงานฟงกชัน SumFloat ไดวา

float sumVal;
sumVal = SumFloat ( a1, a2 );

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

void PrintOut ( float );

77

ฟง กช ันนี้มีการรับคาจาํ นวนจริง 1 คา เปน แบบ float โดยทเ่ี มอ่ื ทาํ งานเสร็จจะไมมีการสงคากลับ เมื่อตองการเรียก
ใชง าน สามารถเรียกใชไดดวยคาํ สง่ั

PrintOut(sumVal);
จะเห็นวาการเรียกใชงานฟงกชันที่ไมมีการสงคากลับนั้นสามารถเรียกใชช ่อื ฟง กชันไดทันทโี ดยไมตอ งมีตวั แปรมา
รบั คา

3. การประกาศโปรโตไทปของฟงกชัน

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

ตวั อยา งที่ 4.3 แสดงการทาํ งานของโปรแกรมการบวกเลขจาํ นวนจริง 2 จํานวนที่รับจากผูใช ในลักษณะที่มีการ
ประกาศโปรโตไทป

#include <stdio.h>

float InputFloat ( );
float SumFloat ( float , float );
void PrintOut ( float );

void main ( ) {
float a1, a2, sumVal;
a1 = InputFloat( );
a2 = InputFloat( );
sumVal = SumFloat ( a1, a2 );
PrintOut ( sumVal );

}
float InputFloat ( ) {

float x;
printf ( “\nInput real value : “ );
scanf ( “%f”, &x );
return ( x );
}
float SumFloat ( float x, float y ) {
return ( x + y );
}

78

void PrintOut ( float x ) {
printf ( “\n Result of sum is : %.2f”, x );

}

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

ตวั อยางที่ 4.4 แสดงการแยกสวนของโปรโตไทปไปไวในอินคลูชไฟลชื่อ myinc.h และการเรียกใชจากโปรแกรม
หลกั

/* myinc.h */
float InputFloat ( );
float SumFloat ( float , float );
void PrintOut ( float );

#include <stdio.h>
#include “myinc.h”

void main ( ) {
float a1, a2, sumVal;
a1 = InputFloat( );
a2 = InputFloat( );
sumVal = SumFloat ( a1, a2 );
PrintOut ( sumVal );

}
float InputFloat ( ) {

float x;
printf ( “\nInput real value : “ );
scanf ( “%f”, &x );
return ( x );
}
float SumFloat ( float x, float y ) {
return ( x + y );
}

79

void PrintOut ( float x ) {
printf ( “\n Result of sum is : %.2f”, x );

}

4. ขอบเขต (Scope)

การทาํ งานของโปรแกรมภาษาซีจะทาํ งานที่ฟงกชัน main ( ) กอ นเสมอ เมื่อฟงกชัน main ( ) เรยี กใชงานฟงกชัน
อน่ื ก็จะมีการสงคอนโทรล (Control) ทค่ี วบคมุ การทาํ งานไปยังฟงกชันนั้น ๆ จนกวาจะจบฟงกชัน หรอื พบคาํ สัง่ return
เมอื่ มกี ารเรยี กใชง านฟงกชันจะมีการจองพื้นที่หนวยความจําสาํ หรับตัวแปรที่ตองใชภายในฟงกชันนั้น และเม่ือสิ้นสดุ การ
ทาํ งานของฟง กช นั ก็จะมีการคืนพื้นที่หนวยความจําสว นนน้ั กลบั สรู ะบบ การใชงานตัวแปรแตละตัวจะมีขอบเขตของการใช
งานขนึ้ อยกู ับตาํ แหนง ทป่ี ระกาศตวั แปรนน้ั จากตัวอยางที่ 4.2 และ 4.3 แสดงการทํางานไดดังรูปที่ 4.8

main ( ) a1 a1 = InputFloat( ); main ( ) a1 a2= InputFloat( );
a2 a2
sumVa 1 sumVal 2

InputFloat ( ) x InputFloat ( ) x

main ( ) a1 main ( ) a1
a2 a2
sumVal 4 3
sumVal = SumFloat(a1, a2); sumVal
PrintSum(sumVal);

PrintSum ( ) x SumFloat ( ) x
y

รปู ท่ี 4.8 แสดงการทํางานของฟงกชัน

เมอื่ เริ่มการทาํ งานที่ฟงกชัน main ( ) จะมกี ารจองพน้ื ทห่ี นว ยความจําใหกับตัวแปรตาง ๆ ที่เกี่ยวของ คือ a1 a2
และ sumVal เมอื่ มีการเรียกใชฟงกชัน InputFloat ( ) ในขน้ั ท่ี 1 จะมีการจองพื้นที่หนวยความจาํ ใหก บั ตวั แปร x และทาํ งาน
รบั ขอ มูลจากผูใ ช เมื่อมีการใชคาํ สั่ง return ( x ); จะมกี ารนําคาในตัวแปร x กาํ หนดใหกับ a1 แลว คนื พน้ื ทเ่ี พอ่ื การทาํ งาน
ของ InputFloat ใหก บั ระบบ

ในขน้ั ตอนท่ี 2 เมื่อมีการเรียกใช InputFloat อกี ครงั้ หน่ึง จะมกี ารจองพน้ื ทใ่ี นหนว ยความจาํ ขึ้นใหม โดยมีตัวแปร
x เชน เดยี วกนั แตเ ปน ตวั แปรคนละตวั กบั ขน้ั ตอนท่ี 1 และมกี ารทํางานเหมือนขั้นตอนท่ี 1

เมอ่ื มกี ารสง่ั ใหค ํานวณคาในขั้นตอนท่ี 3 ดวยฟงกชัน SumFloat ( ) จะมกี ารจองพื้นที่ใหกับตัวแปร x และ y และ
กาํ หนดคา a1 ใหกับ x และกาํ หนด a2 ใหก บั y ฟง กชันนี้จะบวกคาใน x กับ y แลว คนื คา ผลลพั ธก ารคาํ นวณใหกับตัวแปร
sumVal

80

ในขน้ั ตอนสดุ ทา ยเปน การแสดงผลลพั ธด ว ยฟง กช นั PrintSum ( ) จะมกี ารจองพื้นที่ใหกับตัวแปร x เชนเดียวกัน
และกาํ หนดคาของ sumVal ใหก บั ตวั แปร x และแสดงคานั้น

จะเห็นวาตัวแปร x ทปี่ ระกาศในแตละขัน้ ตอนจะทาํ งานอยูภายในฟงกชันที่มีการประกาศคาเทานั้น และใชพ น้ื ท่ี
ในการเกบ็ ขอ มลู คนละสวนกัน ขอบเขตการทาํ งานของตัวแปรแตละตัวจะกาํ หนดอยภู ายบลอ็ กของคาํ สั่งภายในเครื่องหมาย
ปกกา ( { } ) หรอื การประกาศในชวงของการประกาศฟงกชัน เรียกตัวแปรเหลานี้วา ตัวแปรเฉพาะที่ (Local Variable)
นอกจากนส้ี ามารถประกาศตวั แปรไวท ภ่ี ายนอกฟง กช นั บรเิ วณสว นเรม่ิ ของโปรแกรมจะเรยี กวา ตัวแปรสว นกลาง (Global
Variable) ซงึ่ เปน ตวั แปรทสี่ ามารถเรียกใชที่ตาํ แหนงใด ๆ ในโปรแกรมก็ได ยกเวนในกรณีที่มีการประกาศตัวแปรที่มีชื่อ
เดยี วกนั ตวั แปรสวนกลางภายในบล็อกหรือฟงกชัน แสดงดังตัวอยางที่ 4.5

ตวั อยางที่ 4.5 แสดงการทํางานของโปรแกรมในลักษณะที่มีตัวแปรสวนกลาง แสดงขอบเขตการใชงานของตัว
แปรภายในโปรแกรม

#include <stdio.h> /* x is 20 */
int x;
void func1 ( ) { /* x is 30 */

x = x + 10; /* x is 10 */
printf ( “func1 -> x : %d\n”, x );
} /* x is 10 */
void func2 ( int x ) { /* x is 20 */
x = x + 10; /* x is 20 */
printf ( “func2 -> x : %d\n”, x ); /* x is 20 */
}
void func3 ( ) {
int x=0;
x = x + 10;
printf ( “func3 -> x : %d\n”, x );
}

void main ( ) {
x = 10;
printf ( “main (start) -> x : %d\n”, x );
func1 ( );
printf ( “main (after func1) -> x : %d\n”, x );
func2 ( x );
printf ( “main (after func2) -> x : %d\n”, x);
func3 ( );
printf ( “main (after func3) -> x : %d\n”, x);

}

81

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

main (start) -> x : 10
func1 -> x : 20
main (after func1) -> x : 20
func2 -> x : 30
main (after func2) -> x : 20
func3 -> x : 10
main (after func3) -> x : 20

การทาํ งานของตัวแปรสวนกลาง x เรมิ่ ตน มีการกาํ หนดคาในฟงกชัน main ( ) ใหต วั แปรสว นกลาง x มคี า 10 เมื่อ
มกี ารเรียกฟงกชัน func1 ( ) ตวั แปร x ภายในฟง กชันนี้เปนตัวแปรตัวเดียวกับตัวแปรสวนกลาง x เมอื่ มกี ารเพิ่มคาขึ้น 10 คา
ของตวั แปรสวนกลางจึงเปลี่ยนเปน 20

เมอื่ มกี ารเรียกใชฟงกชัน func2 ( ) โดยสงตัวแปรสว นกลาง x เปนอารก ิวเมนตใหกับฟงกชัน func2 ( ) จะมีการจอง
พน้ื ทใ่ี หก บั ตวั แปร x ซงึ่ เปน ตัวแปรเฉพาะที่ใชไดเฉพาะภายในฟงกชัน func2 ( ) เทา นน้ั โดยมีการกาํ หนดใหต วั แปรเฉพาะท่ี
x มคี า เทา กับตัวแปรสว นกลาง x เพราะฉะนัน้ การเปลี่ยนแปลงคาทต่ี ัวแปรเฉพาะท่ี x ในฟง กช ัน func2 ( ) จงึ ไมมีผลกับตัว
แปรสว นกลาง x

ตอ มามีการเรียกใชฟงกชัน func3 ( ) ภายในฟงกชันนี้มีการประกาศตัวแปร x ตวั แปรนเ้ี ปน ตวั แปรเฉพาะทใ่ี ชไ ด
เฉพาะภายในฟง กช นั func3 ( ) เพราะฉะนั้นการอางถึงตัวแปร x ภายในฟง กชันนี้จึงไมมีสวนเกี่ยวของใด ๆ กับตัวแปรสวน
กลาง x

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

5. ฟงกชันแบบเรียกซํา้ (Recursive Functions)

ฟง กช นั แบบเรียกตัวเอง เปนฟงกชันที่สามารถกาํ หนดรูปแบบของฟงกชันในเทอมใด ๆ กับคาของเทอมในกอน
หนา ไดใ นรปู แบบทแ่ี นน อน โดยที่จะตองมีจุดสิ้นสุดของฟงกชันที่แนนอน ตัวอยางของฟงกชันที่สามารถทาํ งานในรูปของ
ฟง กชันแบบเรียกตัวเองได เชน ฟงกชันแฟคทอเรียล (Factorial)

0!=1

1!=1

2!=2*1

3!=3*2*1

………..

ซงึ่ สามารถเขียนฟงกชันแฟคทอเรียลในรูปแบบของความสัมพันธไดดังนี้

n!=1 ในกรณที ี่ n = 0

n ! = n * (n-1) * (n-2) * … * 3 * 2 * 1 ในกรณที ่ี n > 0

กรณที ่ี n = 0 เปน จดุ สิ้นสุดของการเรียกตัวเอง ในกรณีของแฟคทอเรียลฟงกชัน แสดงโปรแกรมดังตัวอยางที่ 4.6

82

ตวั อยา งที่ 4.6 แสดงแฟคทอเรยี ลฟง กช นั ในลกั ษณะของฟงกชันเรียกตัวเอง
#include <stdio.h>

long int fac ( int n ) {
if (n == 0)
return ( 1 );
else
return ( n * fac(n-1) );

}
main ( ) {

int n;
printf (“Input n :> “);
scanf(“%d” , &n);
printf(“ %d factorial is :> %ld “, n, fac(n) );
}

สมมติให n = 3 สามารถแสดงการทํางานไดดังรูปที่ 4.9

main ( ) { /* n = 3 */ fac ( 3 ) fac ( n=3 ) fac ( 2 ) fac ( n=2 )
fac = 6 if (n == 0) fac = 2 if (n == 0)
int n; return ( 1 ); return ( 1 );
else else
printf (“Input n :> “); return(3 * fac(3 - 1)); return(2 * fac(2 - 1));

scanf(“%d” , &n); /* n = 3 */ } }

printf(“ %d factorial is :> %ld “,

n, fac(n) ); /* fac ( 3 ) */

}

fac = 1 fac ( 1 )

fac ( n=0 ) fac ( 0 ) fac ( n=1 )
if (n == 0) fac = 1 if (n == 0)
return ( 1 ); return ( 1 );
else else
return(n* fac(n - 1)); return(1 * fac(1 - 1));

} }

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

83

ตวั อยางที่ 4.7 แสดงแฟคทอเรียลฟง กช นั ในลกั ษณะของฟงกชันปกติ

#include <stdio.h>
long int fac ( int n) {

long int result=1;
for (int i = n; i > 0; i-- )

result *= i;
return ( result );
}
main ( ) {
int n;
printf (“Input n :> “);
scanf(“%d” , &n);
printf(“ %d factorial is :> %ld “, n, fac(n) );
}

ตวั อยา งเพมิ่ เติมในเรื่องฟงกชันแบบเรียกซาํ้ แสดงดังตัวอยางที่ 4.8

ตวั อยา งที่ 4.8 การหาคา เลขยกกาํ ลังดวยฟงกชันแบบเรียกซํ้า

#include <stdio.h>
float power (float val, int pow) {

if (pow == 0)
return(1.0);

else
return(power(val, pow-1) * val);

}
void main( ) {

float b=10.0, ans;
int p=4;
ans = power ( b, p );
printf(“Answer of %f power %d is %f”, b, p, ans);
}

84

6. ตวั อยางเพิ่มเติม

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

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

#include <stdio.h>
#include <conio.h>

long convert(long h, long m, long s) {
long total;
total = (h * 60 + m) * 60 + s;
return (total);

}
void main() {

long hours, minutes, seconds;
long time;

clrscr();
printf("Enter the time to be converted (hh mm ss) : ");
scanf("%ld %ld %ld", &hours, &minutes, &seconds);

time = convert(hours, minutes, seconds);
printf("\nConvert to %ld seconds", time);
getch();
}

85

ตวั อยา งที่ 4.10 เขยี นโปรแกรมเพื่อแสดงรูปกรอบสี่เหลี่ยมโดยใชเครื่องหมาย * ใหผ ใู ชร ะบคุ วามกวา งและความ
สงู ของรูปสี่เหลี่ยมที่ตองการ

#include <stdio.h>
#include <conio.h>
void printHead(int width) {

int i;
for (i=0; i < width+2; i++)

printf("*");
printf("\n");
}
void printBody(int width, int height) {
int i, j;
for (i=0; i < height; i++) {

printf("*");
for (j=0; j < width; j++)

printf(" ");
printf("*\n");
}
}
void main() {
int w, h;
clrscr();
printf("Enter width : ");
scanf("%d", &w);
printf("Enter height : ");
scanf("%d", &h);
printf("\n\n");
printHead(w);
printBody(w, h);
printHead(w);
getch();
}

86

ตวั อยา งที่ 4.11 ใหเ ขยี นโปรแกรมเพอ่ื รบั ขอ มลู จํานวนเต็ม 2 จํานวนจากผูใช โดยที่ขอมูลนั้นตองมากกวา 20
และนอยกวา 60 และหาผลคณู ของขอ มลู ทง้ั 2

#include <stdio.h>
#include <conio.h>
#define YES 1
#define NO 0
int checkNumber(int, int);
int multiply(int, int);
void main() {

int x, y, ans;
int correct=NO;
clrscr();
do {

printf("Enter x : ");
scanf("%d", &x);
printf("Enter y : ");
scanf("%d", &y);
correct = checkNumber(x, y);
} while (!correct);
ans = multiply(x, y);

printf("\nMultiply of %d and %d is %d", x, y, ans);
getch( );
}
int checkNumber(int a, int b) {
if (a > 20 && a < 60 && b > 20 && b < 60)

return (YES);
else {

printf("Input number in range > 20 and <60\n");
return(NO);
}
}
int multiply(int num1, int num2) {
return(num1 * num2);
}

87

7. ไลบรารีมาตรฐานของภาษาซี

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

7.1 ฟง กชันเกี่ยวกับตัวอักขระ
เมอื่ ตอ งการใชฟงกชันเกี่ยวกับตัวอักขระ จะตองมีเรียกใชอินคลูชไฟล <ctype.h> ดว ยคําสงั่
#include <ctype.h>

ฟงกชัน หนาที่
int isalnum(c) ตรวจสอบตวั อกั ขระนน้ั เปน ตวั อกั ขระ 0-9 หรอื a-z หรอื A-Z หรอื ไม (Alphanumeric)
ถา ไมใชคืนคา 0 ถา ใชคืนคาที่ไมใช 0
int isalpha(c) ตรวจสอบตวั อกั ขระนน้ั เปน ตวั ขระ a-z หรอื A-Z หรอื ไม ถาไมใชคืนคา 0 ถา ใชค นื คา ท่ี
ไมใ ช 0
int isdigit(c) ตรวจสอบตวั อกั ขระนน้ั เปน ตวั อกั ขระ 0-9 หรอื ไม ถา ไมใชคืนคา 0 ถา ใชคืนคาที่ไมใช 0
int islower(c) ตรวจสอบตวั อกั ขระนน้ั เปน ตวั อกั ขระ a-z หรอื ไม ถาไมใชคืนคา 0 ถา ใชคืนคาที่ไมใช 0
int isupper(c) ตรวจสอบตวั อกั ขระนน้ั เปน ตวั อกั ขระ A-Z หรอื ไม ถาไมใชคืนคา 0 ถา ใชคืนคาที่ไมใช 0
int tolower(c) แปลงคา อักขระปจจุบันใหเปนอักขระเดียวกันแตเปนตัวพิมพเล็ก
int toupper(c) แปลงคา อักขระปจจุบันใหเปนอักขระเดียวกันแตเปนตัวพิมพใหญ

7.2 ฟง กชันอรรถประโยชนทั่วไป
การเรยี กใชงานฟงกช นั อรรถประโยชนท วั่ ไปจะตองเรยี กใชอ ินคลชู ไฟล <stdlib.h>

ฟงกชัน หนาที่
int abs(int n) หาคาสัมบูรณของคา n
float atof(const char *s) แปลงคาสตริง s เปนคาขอมูลชนิด float
int atoi(const char *s) แปลงคาสตริง s เปนคาขอมูลชนิด int
long atol(const char *s) แปลงคาสตริง s เปนคาขอมูลชนิด long
void exit(int status) เปน คาํ สง่ั เพอ่ื ใชใ นการสน้ิ สดุ การทํางานของโปรแกรม โดยมีการคืนคาสถานะของการ
ทาํ งานของโปรแกรมใหก บั ระบบ โดยทว่ั ไปหากโปรแกรมทํางานสาํ เร็จไมมีขอผิดพลาด
จะคืนคา 0 แตห ากมีขอผิดพลาดจะคืนคาที่ไมใช 0 ซงึ่ ผเู ขียนโปรแกรมอาจจะกาํ หนด
คา ตา ง ๆ ขึ้นใหสอดคลองกับความผิดพลาดที่เกิด

ฟงกชัน 88
void *malloc(size_t size)
หนาที่
int rand(void) ใชจ องพน้ื ทใ่ี นหนว ยความจาํ มีขนาดเทากับ size ไบต คืนคาเปนพอยนเตอรชี้ไปยังพื้นที่
void *realloc(void *ptr, ถา จองได แตถาไมสามารถจองพื้นที่ไดจะคืนคา NULL
คนื คา เลขจาํ นวนเต็มที่สุมขึ้นมาอยูในชวง 0 ถงึ RAND_MAX ซงึ่ ไมเกิน 32767
size_t size) ใชจ ดั การพน้ื ทใ่ี นหนว ยความจาํ ที่มีการจองไวก อนหนานี้ดวยคาํ สงั่ malloc( ) ในตวั แปร
ptr ใหม ดว ยขนาด size ไบต ถาไมสามารถจองพื้นที่ใหมไดจะคืนคา NULL ปกติจะ
เพอ่ื การเพม่ิ หรอื ลดขนาดของพน้ื ทใ่ี นหนว ยความจาํ ทไ่ี ดจ องไวก อ นหนา น้ี

7.3 ฟง กช ันเกี่ยวของกับการรับและแสดงผลขอมูล
การใชง านฟงกชันเกี่ยวของกับการรับและแสดงผลขอมูล จะตองมีการเรียกใชอินคลชู ไฟล <stdio.h>

ฟงกชัน หนาที่
int getchar( ) อานขอมูล 1 อกั ขระจากอุปกรณรับขอมูลมาตรฐาน
char *gets(const char *buffer) อา นขอ มูลสตริงจากอุปกรณรับขอมูลมาตรฐานมาเก็บในตัวแปร buffer จนกวาจะมี
การขนึ้ บรรทัดใหม หากมีความผิดพลาดจะคืนคา NULL
int printf(const char *format, …) ใชแ สดงผลขอ มูลทางอปุ กรณแ สดงผลมาตรฐานในรปู แบบทก่ี ําหนด
int putchar(int c) สง อกั ขระ c ไปแสดงผลทางอปุ กรณแ สดงผลมาตรฐาน
int puts(const char *buffer) สง ขอ มลู สตรงิ buffer ไปแสดงผลทางอปุ กรณแ สดงผลมาตรฐาน
int scanf(const char *format,…) ใชอ า นขอ มลู ทางอปุ กรณร บั ขอ มลู มาตรฐานในรปู แบบทก่ี ําหนด
int sprintf(char *buffer, ทาํ หนาที่คลา ยกับ printf( ) แตจ ะสง ผลของขอ มลู ในรปู แบบทก่ี ําหนดไปเก็บไวใน
สตรงิ buffer
const char *format, …)

7.4 ฟง กชันคณิตศาสตร
การใชง านฟงกชันคณิตศาสตร จะตองเรียกใชอินคลูชไฟล <math.h>

ฟงกชัน หนาที่
acos(x) หาคา Arc Cosine ของ x
asin(x) หาคา Arc Sine ของ x
atan(x) หาคา Arc Tangent ของ x
atan2(x, y) หาคา Arc Tangent ของ x / y
ceil(x) หาคาจาํ นวนจริง x ทมี่ กี ารปดเศษทิ้งทั้งหมด
cos(x) หาคา Cosine ของ x
exp(x) หาคาเอ็กโปเนนเชียล (Exponential) ของ x
floor(x) หาคา จาํ นวนจริง x ทม่ี กี ารปด เศษขน้ึ ทง้ั หมด
log(x) หาคา Logarithm ของ x
log10(x) หาคา Logarithm ฐาน 10 ของ x

ฟงกชัน 89 หนาที่
pow(x, y)
sin(x) หาคา x ยกกาํ ลัง y
sqrt(x) หาคา Sine ของ x
tan(x) หาคา Square Root ของ x
หาคา Tangent ของ x

ตวั อยางที่ 4.12 ใหร บั ขอ มลู เลขจํานวนจริงจากผูใช และแปลงคา เปนเลขจํานวนเต็ม โดยใหมีการปดเศษ หาก
เศษมคี า มากกวา .50 ใหปดเศษขึ้น แตถานอยกวาใหปดเศษลง

#include <stdio.h>
#include <conio.h>

void main( ) {
float f;
char s[21];
int i;
clrscr();
printf("Enter number : ");
scanf("%f", &f);
sprintf(s, "%.0f", f);
i = atoi(s);
printf("Integer number is %d", i);
getch( );

}

1. ใหห าทผ่ี ดิ พลาด และแกไขใหถูกตอง 90 .
.
(ก) #include <stdio.h> แบบฝกหัดบทที่ 4 .
void func 1 ( int ) { .
int a; . .
printf(“A is %d”, a); . .
} . .
void main( ) { . .
int x = 10; . .
func 1 ( x ); . .
} . .
. .
(ข) #include <stdio.h> . .
int main( ) { . .
int a; . .
printf(“Enter number : “); . .
scanf(“%d”, &a); . .
} . .
void main( ) { . .
int a; . .
a = main( ); . .
printf(“A is %d”, a); . .
} . .
. .
(ค) #include <stdio.h> . .
funcY( int , int ) . .
void funcZ( ) . .
void main( ) { . .
int x=10; . .
funcX(x); . .
x = funcZ(x+2); . .
} . .
funcA( ) { . .
funcY(x); . .
printf(“\nx = %d”, x); . .
return(x); . .
} . .
void funcY( ) { . .
printf(“\nx = %d”, x); . .
} .
void funcZ( int ) { .
printf(“\nx = %d”, x); .
} .

91

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

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

int a=20; int a=10;

void func1(int a) { int func2(int x) {

int x; x = x - a;

x = a*2; printf("\n3. x = %d, a = %d", x, a);

printf("\n2. x = %d, a = %d", x, a); return(x);

}}

int func2() { int func1(int a) {

int x; int x;

printf("\n4. x = %d, a = %d", x, a); x = a + 5;

x = a*5; printf("\n2. x = %d, a = %d", x, a);

printf("\n5. x = %d, a = %d", x, a); a = func2(x*2);

return(x); printf("\n4. x = %d, a = %d", x, a);

} return(a);

void main() { }

int x=5; void main() {

printf("\n1. x = %d, a = %d", x, a); int x=0, y=5;

func1(x); printf("\n1. x = %d, y = %d, a = %d", x, y, a);

printf("\n3. x = %d, a = %d", x, a); x = func1(x);

x = func2(); printf("\n5. x = %d, y = %d, a = %d", x, y, a);

printf("\n6. x = %d, a = %d", x, a); y = func2(a);

} printf("\n6. x = %d, y = %d, a = %d", x, y, a);

y = func1(a);

printf("\n7. x = %d, y = %d, a = %d", x, y, a);

}

3. เขยี นโปรแกรมเพอ่ื ทําหนา ทห่ี าผลลพั ธข องการคาํ นวณจากสมการ x = 2ab + c โดยเขยี นฟง กช นั เพอ่ื รบั ขอ มลู เลข

จาํ นวนเต็ม a b และ c ฟง กชันเพื่อคาํ นวณผลลพั ธจ ากสมการ และฟง กช ันเพอ่ื แสดงผลลพั ธ

4. เขยี นโปรแกรมเพอื่ ทาํ หนา ทร่ี บั ขอ มลู เลขจํานวนจริง และคาํ นวณวาเลขนั้นอยูในชวง 100 ถึง 200 หรอื ไม ถาเลขดัง

กลา วอยนู อกชว งทร่ี ะบใุ หว นรบั ขอ มลู นน้ั ใหม จนกวาจะไดเลขในชวงที่ตองการ ใหตรวจสอบวามีการปอนขอมูลทั้ง

หมดกคี่ รงั้ จึงจะไดเลขที่ถูกตอง โดยเขียนในลกั ษณะฟงกชัน

5. เขยี นโปรแกรมเพอ่ื พมิ พก รอบรปู โดยรับขอมูลขนาดคอลมั นและจาํ นวนบรรทดั ของกรอบรปู นน้ั โดยเขียนแยกเปน

ฟง กช นั เพอ่ื การพมิ พก รอบสว นทเ่ี ปน บรรทดั แรกกบั บรรทดั สดุ ทา ย และฟง กชนั สวนท่ีเปน การพมิ พบรรทัดตรงกลาง เชน

Enter column : 10

Enter row : 2

Output :

**********

บรรทดั แรกและบรรทดั สดุ ทา ย * * บรรทดั ตรงกลาง

พมิ พดวยฟงกชัน printHead( ) * * พมิ พดวยฟงกชัน printBody( )

**********

92

6. เขยี นโปรแกรมเพือ่ ทาํ การคาํ นวณคาผลตางของตัวเลข 2 จํานวน คือ A และ B โดยเขียนฟงกชันเพื่อการคาํ นวณผล
ตา งน้ี กาํ หนดใหถา A มคี ามากกวา B ผลลพั ธท ไ่ี ดจะเทา กบั A-B นอกจากนน้ั ผลลพั ธท ไ่ี ดจะเทา กบั B-A

7. เขยี นโปรแกรมเพอ่ื พมิ พค า ของ y โดยที่ y = 4x2 + 3x + 2 สาํ หรบั คา x ที่เทากับ 1, 3, 5, 7, …, 21
8. เขยี นโปรแกรมเพอ่ื ทาํ การหาผลคณู ของเลขคู N จาํ นวน (นบั เลข 2 เปนตัวที่ 1) โดยรับคา N จากผูใช เชน N = 3 จะ

ทาํ การคาํ นวณ 2 * 4 * 6 ผลลพั ธท ไ่ี ดคอื 48 กาํ หนดโปรโตไทปของฟงกช ันเพ่อื หาผลคูณ คือ
long cal ( int ) ;

เมอื่ ขอมูลที่สงเขาฟงกชันคือ N และฟงกชันคืนคาของผลคูณที่หาได
9. เขยี นโปรแกรมเพื่อทาํ การหาผลบวกของอนกุ รม โดยกาํ หนดใหรับคาตัวเลขเริ่มตนของอนุกรม และตัวเลขสุดทายของ

อนกุ รม จากนัน้ นาํ ตัวเลขทั้งหมดในอนุกรมนั้นมาบวกกัน สมมติ ตัวเลขเริ่มตน คือ 5 ตัวเลขตัวสุดทายคือ 10 จะทํา
การนําตัวเลขตั้งแต 5 – 10 มาบวกกัน ผลลพั ธท ไ่ี ดค อื 45 เปนตน กาํ หนดโปรโตไทปเ พอ่ื หาผลรวม คือ

long cal ( int, int ) ;
โดยทข่ี อ มลู เขาฟง กชันตัวแรกคอื เลขเร่มิ ตน ขอมูลเขาฟงกชันตัวที่ 2 คือ เลขทส่ี น้ิ สดุ และคืนคา ผลรวมของอนุกรม
10. ใหเ ขยี นโปรแกรมเพอ่ื แสดงผลลพั ธข องการแปลงเลขฐานสบิ ใหเปนเลขฐาน 8 และฐาน 16 ตามลําดับ โดยใหร บั เลข
ตงั้ ตน และเลขตัวสุทายที่ตองการใหแสดงผลจากผูใช

กาํ หนดใหแ สดงผลลพั ธด งั น้ี หากผูใชปอนเลขตั้งตน คือ 20 และเลขสดุ ทายคือ 30

Dec Oct Hex
20 24 14
21 25 15
………
30 36 1E

11. เขยี นโปรแกรมเพอื่ คาํ นวณปริมาณสีที่ใชในการทาหอง 1 หอ ง โดยใหผูใชระบุความกวาง ความยาว และความสูงของ
หอ ง มหี นว ยเปน ฟุต (ทั้งนี้ยังไมตอง พิจารณาแยกพื้นที่ของประตู หนา ตา ง - ใหคิดรวมกัน) กาํ หนดใหส ี 1 แกลลอนทา
พน้ื ทไ่ี ด 250 ตร.ฟตุ

12. เขยี นโปรแกรมเพื่อรับขอมูลความยาวดาน 3 ดานของรูปสามเหลี่ยม และทดสอบวา ดานทัง้ 3 ทผ่ี ใู ชป อ นเขา สรู ะบบเปน
ดา นของ รปู สามเหลี่ยมเดียวกันหรือไม (วิธีตรวจสอบ ผลรวมของดา น 2 ดานของสามเหลี่ยมตองมากกวาดานที่ 3
เสมอ)

13. เขยี นโปรแกรมเพอ่ื ทําการคาํ นวณผลบวกของเลขคี่ N จาํ นวน โดยกาํ หนดใหเขียนฟงกชันเพื่อการคํานวณดังกลาว
ตวั อยา งการทาํ งานของฟงกชันนี้ เชน cal(5) = 25
cal(2) = 3

14. เขยี นโปรแกรมเพื่อตรวจสอบวาเลขจาํ นวนเต็มที่รับคาเขามาเปน จาํ นวนเฉพาะหรือไม (จาํ นวนเฉพาะ คือ เลข
จาํ นวนเตม็ บวกทม่ี ากกวา 1 ที่นอกจาก 1 และตัวมันเองแลวไมมีเลขจาํ นวนใดหารลงตัว) โดยกาํ หนดใหเขียนฟงกชัน
เพอื่ การตรวจสอบดังกลาว

15. เขยี นโปรแกรมเพอ่ื ทาํ การรับคาตัวแปรจาํ นวนเต็มบวก จากนนั้ ทาํ การสลับตาํ แหนงของเลขจาํ นวนนั้น กาํ หนดใหเ ลขท่ี
รบั เขา มามคี า อยใู นชว งเลขจํานวนเต็มมีคาไมเกิน 9999 โดยขั้นตอนของการสลับคาใหเขียนฟงกชันเพื่อเรียกใชงาน
กาํ หนดใหชื่อฟงกชัน reverse(n) ซงึ่ มีหลักการทํางานดังนี้
ตวั อยาง reverse(1234) = 4321
reverse(223) = 322 เปนตน

93

16. เขยี นโปรแกรมเพอื่ แสดงตารางสูตรคูณดังตัวอยางขางลาง โดยใหผูใชกาํ หนดขอบเขตของแมสูตรคูณ เชนผูใชปอน 4

และ 3 ใหแ สดงผลลพั ธด งั ตัวอยาง

x1234

11234

22468

3 3 6 9 12

17. เขยี นโปรแกรมเพอ่ื ทาํ การรับคาตัวเลขจํานวนเต็มบวกคาหนึ่ง จากน้นั ทาํ การนบั จาํ นวนของตัวเลข 0-9 ท่ีผูใ ชระบซุ ง่ึ

ปรากฏในตวั เลขจํานวนเต็มบวกนั้น โดยมีคาไมเกิน 9999 กาํ หนดใหเขียนฟงกชัน count(n,k) เพอ่ื ทาํ หนา ทใ่ี นการ

นบั ดงั กลาว ซึ่งมีหลักการทํางานดังนี้

ตวั อยาง count(4214,4) = 2

count(73,5) = 0

18. เขยี นโปรแกรมเพอ่ื ทาํ การพิมพ N เทอมแรกของอนกุ รม Fibonacci ซงึ่ กาํ หนดให 2 เทอมแรกมีคาเทากับ 1,1

(อนกุ รม Fibonacci หมายถงึ อนุกรมที่มีแตละเทอมเปนคาผลบวกของ 2 เทอมที่อยูกอน เชน 1,1,2,3,5,8,13,…)

โดยกาํ หนดใหเ ขยี นฟง กช นั เพอ่ื การพมิ พผ ลลพั ธด งั กลา ว ใหเขียนในลกั ษณะ Recursive และเขียนในลักษณะธรรมดา

19. เขยี นโปรแกรมเพื่อคาํ นวณรายไดของเซลแมนคนหนึ่ง โดยรบั ขอ มลู รหสั พนกั งาน ยอดขาย ตน ทนุ และใหแสดงรายงาน

ตา ง ๆ คือ รหสั พนกั งาน ยอดขาย ตน ทนุ กาํ ไร ( = ยอดขาย - ตน ทนุ ) และคาคอมมิชชนั แสดงดังตัวอยางขางลาง

กาํ หนดวา หากยอดขายมีมูลคาไมเกิน 5000 ใหคิดคาคอมมิชชนั 10 เปอรเซ็นตของกาํ ไร แตหากเกินกวานั้นใหคิดคอม

มิชชนั ที่ 5 เปอรเซ็นตของกาํ ไร ตัวอยางผลลพั ธก ารทาํ งาน

Number Sales Value Profit Commission

----------- --------- -------- --------- ----------------

1234 234.56 174.56 60.00 6.00

----------- --------- -------- --------- ----------------

พอยนเตอร

( Pointer ) 5

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

1. พอยนเตอรกับแอดเดรส (Pointers and Addresses)

การประกาศตัวแปร เชน int i; หากพจิ ารณาคําสั่งดังกลาวจะเปนการประกาศ (Declaration) ตวั แปรชื่อ i
เปน ตวั แปรประเภท int จะแสดงภาพจําลองการแทนขอ มลู ในหนว ยความจาํ ไดดังรูปที่ 5.1

int i; int i; i 400 i = 10; i 10 400
i = 10; 402 402
404 404

รปู ท่ี 5.1 แสดงการแทนขอ มลู ในหนว ยความจาํ ของตัวแปรประเภทพื้นฐาน

เมอื่ มกี ารประกาศตัวแปรจะมีการจองพื้นที่หนวยความจาํ ที่มีขนาดเทากับประเภทของตัวแปรนั้น การอาง
องิ ตวั แปรจะเปน การอา งถึงแอดเดรสหรือตาํ แหนงที่อยูในหนวยความจาํ ในที่นี้สมมติวามีการจองพื้นที่ที่แอดเดรส
400 ใหก บั ตวั แปร i ( ขนาดของตวั แปรแตละประเภทในภาษาซีขึ้นอยูกับบริษัทผูผลิตคอมไพเลอร สามารถตรวจ
สอบไดจากคูมือ ) เมอ่ื มกี ารนาํ ตัวแปรนั้นมาใชงาน เชน คําสัง่ i = 10; จะเปนการกาํ หนดให i มคี า เทา กับ 10 จะ
มกี ระบวนการเก็บคานั้นลงในพื้นที่หนวยความจําที่จองไว ในที่นี้คือแอดเดรส 400 ดังรูปท่ี 5.1

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