Embedded Files
สำหรับบทนี้จะอธิบายถึงคำสั่งควบคุมการทำงานของโปรแกรม ซึ่งแบ่งกลุ่มตามลักษณะการทำงานตามข้อกำหนดมาตรฐานของสถาบัน ANSI (American National Standards Institute) กำหนดให้ภาษา C มีคำสั่งที่ใช้ควบคุมการทำงานของโปรแกรมดังนี้
1) คำสั่งวนลูปหรือทำงานซ้ำ ๆ เป็นลูป (loop statements) ได้แก่ คำสั่ง for, while, do while และมีคำสั่งออกจากลูปคือคำสั่ง break หรือทำงานในรอบต่อไป คือคำสั่ง continue
2) คำสั่งทดสอบเงื่อนไขในการตัดสินใจ (decision statements) ได้แก่ คำสั่ง if, if else, โครงสร้าง else if (หรือ nested if) และคำสั่ง switch
3) คำสั่งที่สั่งให้ไปทำงานตามจุดที่กำหนดให้ (goto statements) ได้แก่ คำสั่ง goto และ label ซึ่งแต่ละคำสั่งมีรายละเอียดดังต่อไปนี้
4.1 คำสั่งวนลูปหรือทำงานซ้ำ ๆ เป็นลูป (loop statements)
คำสั่งวนลูปเป็นคำสั่งที่สามารถควบคุมโปรแกรมให้ทำงานเป็นจำนวนรอบตามที่เรากำหนดไว้ หรือทำงานจนกว่าเงื่อนไขที่กำหนดไว้เป็นเท็จ จึงจะออกจากคำสั่งวนลูปได้
4.1.1 คำสั่ง for
for เป็นคำสั่งที่สั่งให้โปแกรมมีการทำงานซ้ำ ๆ วนลูปจนกว่าเงื่อนไขที่กำหนดไว้เป็นเท็จ จึงออกจากคำสั่ง for ไปทำคำสั่งถัดไป ควรใช้คำสั่ง for ในกรณีที่ทราบจำนวนรอบของการทำงาน
รูปแบบการใช้คำสั่ง for
for (expression1; expression2; expression3)
statement;
หรือ
for (expression1; expression2; expression3)
{
statement(s);
}
โดยที่
expression1 คือ นิพจน์ที่ใช้กำหนดค่าเริ่มต้นให้กับตัวแปรที่จะใช้วนลูป
expression2 คือ นิพจน์ที่ใช้ทดสอบเงื่อนไข ซึ่งจะมีค่าจริงหรือเท็จอย่างใดอย่างหนึ่งเท่านั้น
expression3 คือ นิพจน์ที่ใช้เพิ่มหรือลดค่าตัวแปรที่จะใช้วนลูป
statement(s) คือ คำสั่งต่าง ๆ ถ้ามีมากกว่า 1 คำสั่ง จะต้องเขียนอยู่ภายในเครื่องหมาย {….}
ลักษณะการทำงานของคำสั่ง for สามารถเขียนเป็นแผนผังได้ดังนี้
รูปที่ 4.1 ผังงานแสดงลักษณะการทำงานของคำสั่ง for
ที่มา : สมชาย รัตนเลิศนุสรณ์, 2545 : 78.
โปรแกรมตัวอย่างที่ 4.1 แสดงการใช้คำสั่ง for เพื่อวนแสดงตัวเลข 1 ถึง 10 ออกแสดงที่จอภาพ
/* for1.c */
#include<stdio.h> /* บรรทัดที่ 1 */
#include<conio.h> /* บรรทัดที่ 2 */
void main(void) /* บรรทัดที่ 3 */
{ /* บรรทัดที่ 4 */
int num; /* บรรทัดที่ 5 */
clrscr( ); /* บรรทัดที่ 6 */
for (num=1; num<=10; num++) /* บรรทัดที่ 7 */
printf( "%3d\n", num); /* end for */ /* บรรทัดที่ 8 */
printf("\n\nPress any key back to program..."); /* บรรทัดที่ 9 */
getch(); /* บรรทัดที่ 10 */
} /* บรรทัดที่ 11 */
ผลลัพธ์ที่ได้จากโปรแกรม
คำอธิบายโปรแกรม
จากโปรแกรมตัวอย่างที่ 4.1 สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ ได้ดังนี้
บรรทัดที่ 7 คำสั่ง for (num = 1; num <=10; num++) จะเริ่มทำงานโดยการกำหนดค่าเริ่มต้นตัวแปร num เป็น 1 จากนั้นทดสอบเงื่อนไข num <= 10 จริงหรือเท็จ ถ้าเป็นจริงจะทำงานตามคำสั่งบรรทัดที่ 8 ถ้าเป็นเท็จออกจาก for ไปทำคำสั่งบรรทัดที่ 9
บรรทัดที่ 8 ฟังก์ชัน printf( ) เพื่อพิมพ์ค่าของตัวแปร num ในแต่ละรอบของการทำงาน และขึ้นบรรทัดใหม่ด้วย ออกแสดงที่จอภาพ
บรรทัดที่ 9 ฟังก์ชัน printf( ) แสดงข้อความให้กดคีย์ใด ๆ เพื่อกลับสู่โปรแกรม
บรรทัดที่ 10 หยุดรอรับค่าใด ๆ จากคีย์บอร์ด เช่น ถ้ากด enter ก็จะกลับสู่โปรแกรม
โปรแกรมตัวอย่างที่ 4.2 แสดงการใช้คำสั่ง for เพื่อวนคำนวณแม่สูตรคูณ แม่ต่าง ๆ ตามผู้ใช้เติม และแสดงผลที่จอภาพ
/* for2.c */
#include<stdio.h> /* บรรทัดที่ 1 */
#include<conio.h> /* บรรทัดที่ 2 */
void main(void) /* บรรทัดที่ 3 */
{ /* บรรทัดที่ 4 */
int k,i; /* บรรทัดที่ 5 */
clrscr(); /* บรรทัดที่ 6 */
printf("input number >>> "); /* บรรทัดที่ 7 */
scanf("%d",&k); /* บรรทัดที่ 8 */
for (i=1; i<=12; i++) /* บรรทัดที่ 9 */
printf("%d x %d = %d\n",k,i,i*k); /* บรรทัดที่ 10 */
printf("\n\nPress any key back to program..."); /* บรรทัดที่ 11 */
getch(); /* บรรทัดที่ 12 */
} /* บรรทัดที่ 13 */
ผลลัพธ์ที่ได้จากโปรแกรม
คำอธิบายโปรแกรม
จากโปรแกรมตัวอย่างที่ 4.2 สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ ได้ดังนี้
บรรทัดที่ 7 ฟังก์ชัน printf( ) พิมพ์ข้อความ input number >>> ออกที่จอภาพ นั่นคือ ให้ผู้ใช้เติมตัวเลขจำนวนเต็ม เพื่อที่จะนำไปคำนวณแม่สูตรคูณ
บรรทัดที่ 8 ฟังก์ชัน scanf( ) รับค่าตัวเลขจากคีย์บอร์ด แล้วเก็บไว้ที่ตัวแปร k
บรรทัดที่ 9 คำสั่ง for (i = 1; i <= 12; i++) เป็นการกำหนดค่าเริ่มต้นตัวแปร i เป็น 1 จากนั้นทดสอบเงื่อนไข i <= 12 จริงหรือเท็จ ถ้าเป็นจริงจะทำคำสั่งบรรทัดที่ 10 ถ้าเป็นเท็จจะออกจาก for ไปทำคำสั่งบรรทัดที่ 11
บรรทัดที่ 10 ฟังก์ชัน printf( ) แสดงค่าตัวแปร k, i และ i * k นั่นคือ ค่าแม่สูตรคูณตัวเลขนั้น ๆ คูณกับค่า i ในแต่ละรอบ และค่าผลลัพธ์ที่ได้จากการเอาตัวเลขแม่สูตรคูณ คูณกับตัวเลขในแต่ละรอบออกมาเป็นสูตรคูณ
บรรทัดที่ 11 ฟังก์ชัน printf( ) พิมพ์ข้อความให้กดคีย์ใด ๆ เพื่อกลับสู่โปรแกรม
บรรทัดที่ 12 หยุดรอรับค่าใด ๆ จากคีย์บอร์ด เช่น ถ้ากด enter ก็จะกลับสู่โปรแกรม
โปรแกรมตัวอย่างที่ 4.3 แสดงการใช้คำสั่ง for เพื่อวนคำนวณค่าสะสมตัวเลข 1 ถึง 10 และแสดงผลออกจอภาพ
/* for3.c */
#include<stdio.h> /* บรรทัดที่ 1 */
#include<conio.h> /* บรรทัดที่ 2 */
void main(void) /* บรรทัดที่ 3 */
{ /* บรรทัดที่ 4 */
int i, sum; /* บรรทัดที่ 5 */
clrscr( ); /* บรรทัดที่ 6 */
for( i=1, sum=0; i<=10; i++ ) /* บรรทัดที่ 7 */
{ /* บรรทัดที่ 8 */
sum+=i; /* บรรทัดที่ 9 */
printf("I = %d, SUM = %d\n", i, sum); /* บรรทัดที่ 10 */
} /* end for */ /* บรรทัดที่ 11 */
printf("\n\nI = %d, SUM = %d",i,sum); /* บรรทัดที่ 12 */
printf("\n\nPress any key back to program..."); /* บรรทัดที่ 13 */
getch(); /* บรรทัดที่ 14 */
} /* บรรทัดที่ 15 */
ผลลัพธ์ที่ได้จากโปรแกรม
คำอธิบายโปรแกรม
จากโปรแกรมตัวอย่างที่ 4.3 สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ ได้ดังนี้
บรรทัดที่ 7 คำสั่ง for (i = 1, sum = 0; i <= 10; i++) มีนิพจน์ที่กำหนดค่าเริ่มต้นให้กับตัวแปร 2 ค่า คือ i = 1 และ sum = 0 ส่วนนิพจน์เงื่อนไข คือ i <= 10 และนิพจน์สำหรับเพิ่มค่าตัวแปร i คือ i++ ในคำสั่ง for ถ้าตรวจสอบเงื่อนไข i <=10 แล้วเป็นจริงจะทำงานใน loop for คือ บรรทัดที่ 9 และ 10 แล้ววนไปเพิ่มค่าตัวแปร i และวนตรวจสอบเงื่อนไขอีกครั้งว่า i <= 10 จริงหรือเท็จ แต่ถ้าตรวจสอบเงื่อนไขแล้วได้ค่าเป็นเท็จ ก็จะข้ามคำสั่งใน loop for ไปทำคำสั่งบรรทัดที่ 12 ถึง 14
บรรทัดที่ 9 และ 10 เป็นคำสั่งให้คำนวณค่าสะสมตัวแปร sum ในแต่ละรอบการทำงาน และแสดงค่าตัวแปร i และตัวแปร sum ที่คำนวณได้ในแต่ละรอบ แสดงผลออกจอภาพ
บรรทัดที่ 12 ถึง 14 เป็นคำสั่งที่โปรแกรมจะทำงานภายหลังจากตรวจสอบเงื่อนไข loop for แล้วได้ค่าเป็นเท็จ นั่นคือ บรรทัดที่ 12 พิมพ์ค่าตัวแปร i และ ตัวแปร sum ค่าสุดท้าย ส่วนบรรทัดที่ 13 จะแสดงข้อความให้กดคีย์ใด ๆ เพื่อกลับสู่โปรแกรม และบรรทัดที่ 14 หยุดรอรับค่าใด ๆ จากคีย์บอร์ด เช่น ถ้ากด enter ก็จะกลับสู่โปรแกรม
โปรแกรมตัวอย่างที่ 4.4 แสดงการใช้คำสั่ง for เพื่อวนแสดงตัวเลขแต่ละแถว ซึ่งแสดงแถวละ 10 ตัว ออกแสดงที่จอภาพ
/* for4.c */
#include<stdio.h> /* บรรทัดที่ 1 */
#include<conio.h> /* บรรทัดที่ 2 */
void main(void) /* บรรทัดที่ 3 */
{ /* บรรทัดที่ 4 */
int row, col; /* บรรทัดที่ 5 */
clrscr( ); /* บรรทัดที่ 6 */
for (row=1; row<=5; row++) /* บรรทัดที่ 7 */
{ /* บรรทัดที่ 8 */
for( col=1; col<=10 ; col++ ) /* บรรทัดที่ 9 */
printf("%2d",row ); /* บรรทัดที่ 10 */
printf("\n"); /* บรรทัดที่ 11 */
} /* end for(row) */ /* บรรทัดที่ 12 */
printf("\n\nPress any key back to program..."); /* บรรทัดที่ 13 */
getch(); /* บรรทัดที่ 14 */
} /* บรรทัดที่ 15 */
ผลลัพธ์ที่ได้จากโปรแกรม
คำอธิบายโปรแกรม
จากโปรแกรมตัวอย่างที่ 4.4 สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ ได้ดังนี้
บรรทัดที่ 7 คำสั่ง for (row=1; row<=5; row++) เพื่อควบคุมการทำงานของโปรแกรมให้มีการทำงานจำนวน 5 แถว และมีนิพจน์เงื่อนไข คือ row<=5 เป็นจริงหรือเท็จ ถ้านิพจน์เงื่อนไขมีค่าจริง จะทำงานใน loop for คือ บรรทัดที่ 9 ถึง 11 แล้ววนไปเพิ่มค่าตัวแปร row และวนตรวจสอบเงื่อนไขอีกครั้งว่า row<=5 จริงหรือเท็จ แต่ถ้าตรวจสอบเงื่อนไขแล้วได้ค่าเป็นเท็จ ก็จะข้ามคำสั่งใน loop for ไปทำคำสั่งบรรทัดที่ 14 และ 15
บรรทัดที่ 9 คำสั่ง for (col=1; col<=10; col++) เพื่อควบคุมการทำงานของโปรแกรมให้ทำงาน 10 คอลัมน์ ต่อ 1 แถว ซึ่งการทำงานใน loop for นี้ มีลักษณะการทำงานคล้ายกับ loop for ของบรรทัดที่ 7 ซึ่งถ้านิพจน์เป็นจริง จะไปทำงานคำสั่งบรรทัดที่ 10 นั่นคือ วนพิมพ์ค่าของตัวแปร row ไปเรื่อย ๆ จนครบ 10 ครั้ง และแต่ละครั้งจะเว้นช่องว่างห่างกัน 2 ช่องว่างสำหรับการแสดงค่าตัวแปร row แต่ถ้านิพจน์เป็นเท็จ จะไปทำคำสั่งบรรทัดที่ 11 นั่นคือ ขึ้นบรรทัดใหม่
บรรทัดที่ 13 และ 14 เป็นคำสั่งที่โปรแกรมจะทำงานภายหลังจากตรวจสอบเงื่อนไขของตัวแปร row ว่า row<=5 แล้วได้ค่าเป็นเท็จ คือ แสดงข้อความให้กดคีย์ใด ๆ เพื่อกลับเข้าสู่โปรแกรม และจะหยุดรอรับค่าใด ๆ จากคีย์บอร์ด เช่น กด enter ก็จะกลับสู่โปรแกรม
4.1.2 คำสั่ง while
while เป็นคำสั่งที่มีการทำงานซ้ำ ๆ เป็นลูป และมีลักษณะการทำงานของคำสั่งคล้ายกับคำสั่ง for แตกต่างกันตรงที่ การใช้ while ไม่ต้องทราบจำนวนรอบของการทำงานที่แน่นอน แต่ต้องมีเงื่อนไขที่เป็นเท็จจึงจะออกจากคำสั่ง while ได้
รูปแบบการใช้คำสั่ง while
while (expression) statement;
หรือ
while (expression)
{
statement(s);
}
โดยที่
expression คือ นิพจน์ที่ใช้ทดสอบเงื่อนไข ถ้านิพจน์นี้ให้ผลลัพธ์เป็นจริงจะทำตามคำสั่งที่อยู่ภายในคำสั่ง while จนกว่าเงื่อนไขเป็นเท็จจึงออกจากคำสั่ง while ได้
ลักษณะการทำงานของคำสั่ง while สามารถเขียนเป็นแผนผังได้ดังนี้
รูปที่ 4.2 ผังงานแสดงลักษณะการทำงานของคำสั่ง while
ที่มา : สมชาย รัตนเลิศนุสรณ์, 2545 : 82.
โปรแกรมตัวอย่างที่ 4.5 แสดงการใช้คำสั่ง while เพื่อวนคำนวณค่าสะสมตัวเลข 1 ถึง 10 และหาค่าเฉลี่ย แล้วแสดงผลออกจอภาพ
/* while1.c */
#include<stdio.h> /* บรรทัดที่ 1 */
#include<conio.h> /* บรรทัดที่ 2 */
void main(void) /* บรรทัดที่ 3 */
{ /* บรรทัดที่ 4 */
int n=1; /* บรรทัดที่ 5 */
float sum =0 , avg; /* บรรทัดที่ 6 */
clrscr( ); /* บรรทัดที่ 7 */
while ( n < 11 ) /* บรรทัดที่ 8 */
{ /* บรรทัดที่ 9 */
sum+=n; /* บรรทัดที่ 10 */
n++; /* บรรทัดที่ 11 */
} /* end while */ /* บรรทัดที่ 12 */
n--; /* บรรทัดที่ 13 */
avg = sum/n; /* บรรทัดที่ 14 */
printf("N = %d, Sum = %.2f\n",n, sum); /* บรรทัดที่ 15 */
printf("Average = %.2f", avg); /* บรรทัดที่ 16 */
printf("\n\nPress any key back to program..."); /* บรรทัดที่ 17 */
getch(); /* บรรทัดที่ 18 */
} /* บรรทัดที่ 19 */
ผลลัพธ์ที่ได้จากโปรแกรม
คำอธิบายโปรแกรม
จากโปรแกรมตัวอย่างที่ 4.5 สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ ได้ดังนี้
บรรทัดที่ 8 คำสั่ง while (n < 11) เพื่อควบคุมการทำงานของโปรแกรมให้ทำงานซ้ำ ๆ กัน โดยการทำงานของคำสั่ง while จะตรวจสอบเงื่อนไข n < 11 เป็นจริงหรือเท็จ ถ้าเป็นจริงจะทำงานตามคำสั่งที่อยู่ภายใน loop while คือ บรรทัดที่ 10 และ 11 จากนั้นจะกลับมาตรวจสอบเงื่อนไขใหม่ ทำอย่างนี้ซ้ำ ๆ จนกว่าตรวจสอบเงื่อนไข n < 11 เป็นเท็จ จึงจะออกจาก loop while แล้วไปทำคำสั่งบรรทัดที่ 13 ถึง คำสั่งบรรทัดที่ 18
บรรทัดที่ 10 และ 11 เป็นคำสั่งที่โปรแกรมจะทำงานภายหลังจากตรวจสอบเงื่อนไข while แล้วเป็นจริง นั่นคือ คำนวณค่าสะสมของตัวแปร sum และ เพิ่มค่า n ทีละ 1 ตามลำดับ
บรรทัดที่ 13 ถึง 18 เป็นคำสั่งที่โปรแกรมจะทำงานภายหลังจากตรวจสอบเงื่อนไข while แล้วเป็นเท็จ คือ ลดค่าตัวแปร n ลง 1 แล้วคำนวณค่าเฉลี่ยเก็บไว้ที่ตัวแปร avg และพิมพ์ค่าตัวแปร n, sum และ avg แสดงที่จอภาพ พร้อมกับพิมพ์ข้อความให้กดคีย์ใด ๆ เพื่อกลับสู่โปรแกรม สุดท้ายจะหยุดรอรับค่าใด ๆ จากคีย์บอร์ด เช่น ถ้ากด enter ก็จะกลับสู่โปรแกรม
โปรแกรมตัวอย่างที่ 4.6 แสดงการใช้คำสั่ง while เพื่อวนทำงานให้ผู้ใช้เติมตัวอักษร และ แสดงผลออกจอภาพไปเรื่อย ๆ จนกว่าจะกด enter ถึงหยุดการทำงาน
/* while2.c */
#include<stdio.h> /* บรรทัดที่ 1 */
#include<conio.h> /* บรรทัดที่ 2 */
void main(void) /* บรรทัดที่ 3 */
{ /* บรรทัดที่ 4 */
char ch='A'; /* บรรทัดที่ 5 */
while (ch != '\r') /* บรรทัดที่ 6 */
{ /* บรรทัดที่ 7 */
clrscr(); /* บรรทัดที่ 8 */
printf("Enter a character : "); /* บรรทัดที่ 9 */
ch=getche(); /* บรรทัดที่ 10 */
printf("\nYour type a character is...%c", ch); /* บรรทัดที่ 11 */
getch(); /* บรรทัดที่ 12 */
} /* end while */ /* บรรทัดที่ 13 */
} /* บรรทัดที่ 14 */
ผลลัพธ์ที่ได้จากโปรแกรม
คำอธิบายโปรแกรม
จากโปรแกรมตัวอย่างที่ 4.6 สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ ได้ดังนี้
บรรทัดที่ 5 ประกาศตัวแปรชนิดตัวอักขระ ชื่อ ch และให้เก็บค่า ‘A’ เพื่อไว้ตรวจสอบเงื่อนไขเริ่มแรก
บรรทัดที่ 6 คำสั่ง while (ch != ‘ \r ’) คือ การตรวจสอบเงื่อนไข ค่าของตัวแปร ch ไม่เท่ากับ ‘ \r ‘ หรือไม่ (‘ \r ‘ คือรหัสของการกดแป้น enter) ซึ่งถ้าเงื่อนไขเป็นจริง จะทำคำสั่งภายใน loop while คือ บรรทัดที่ 8 ถึง 12 แต่ถ้าเงื่อนไขเป็นเท็จก็จะออกจาก loop while ซึ่งในกรณีนี้เงื่อนไขจะเป็นเท็จได้คือผู้ใช้จะต้องกดแป้น enter เพราะ ‘ \r ‘ ไม่เท่ากับ ‘ \r ‘ จะเป็นเท็จ
บรรทัดที่ 8 ถึง 12 เป็นคำสั่งที่โปรแกรมจะทำงานภายหลังจากตรวจสอบเงื่อนไข while แล้วเป็นจริง คือ ลบจอภาพ แล้วให้เติมตัวอักขระตัวใด ๆ ไปเก็บไว้ในตัวแปร ch เพื่อเอาไว้ตรวจสอบเงื่อนไข และนำค่าตัวอักขระที่ผู้ใช้เติมแสดงออกจอภาพ สุดท้ายหยุดรอรับค่าใด ๆ จากคีย์บอร์ด เช่น ถ้ากด enter ก็จะกลับสู่โปรแกรม
โปรแกรมตัวอย่างที่ 4.7 แสดงการใช้คำสั่ง while เพื่อวนการทำงานให้ผู้ใช้เติมตัวเลข เต็มบวก หรือ เต็มลบ หรือ ศูนย์ และมีการนับจำนวนตัวเลขแต่ละชนิดด้วย แล้วแสดงผลที่ได้ออกจอภาพ
/* while3.c */
#include <stdio.h> /* บรรทัดที่ 1 */
#include <conio.h> /* บรรทัดที่ 2 */
void main(void) /* บรรทัดที่ 3 */
{ /* บรรทัดที่ 4 */
float in_key; /* บรรทัดที่ 5 */
int p=0,z=0,n=0, c=1; /* บรรทัดที่ 6 */
clrscr(); /* บรรทัดที่ 7 */
while (c<=10) /* บรรทัดที่ 8 */
{ /* บรรทัดที่ 9 */
printf("Enter a value %d : ", c); /* บรรทัดที่ 10 */
scanf("%f", &in_key); /* บรรทัดที่ 11 */
if (in_key<0.0) /* บรรทัดที่ 12 */
n++; /* บรรทัดที่ 13 */
else if (in_key==0.0) /* บรรทัดที่ 14 */
z++; /* บรรทัดที่ 15 */
else /* บรรทัดที่ 16 */
p++; /* บรรทัดที่ 17 */
c++; /* บรรทัดที่ 18 */
} /* บรรทัดที่ 19 */
printf("Negative = %d\n", n); /* บรรทัดที่ 20 */
printf("Positive = %d\n", p); /* บรรทัดที่ 21 */
printf("Zero = %d\n", z); /* บรรทัดที่ 22 */
getch(); /* บรรทัดที่ 23 */
} /* บรรทัดที่ 24 */
ผลลัพธ์ที่ได้จากโปรแกรม
คำอธิบายโปรแกรม
จากโปรแกรมตัวอย่างที่ 4.7 สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ ได้ดังนี้
บรรทัดที่ 8 คำสั่ง while (c<=10) เพื่อควบคุมการทำงานของโปรแกรมให้ทำงานซ้ำ ๆ กัน โดยการทำงานของคำสั่ง while จะตรวจสอบเงื่อนไข c<=10 เป็นจริงหรือเท็จ ถ้าเป็นจริงจะทำงานตามคำสั่งที่อยู่ภายใน loop while คือคำสั่งบรรทัดที่ 10 ถึง 18 แต่ถ้าเงื่อนไขเป็นเท็จจะออกจาก loop while ไปทำคำสั่งบรรทัดที่ 20 ถึง 23
บรรทัดที่ 10 ถึง 11 ให้ผู้ใช้เติมตัวเลขใด ๆ จะเป็นตัวเลขลบ บวก หรือศูนย์ แล้วเก็บไว้ที่ตัวแปร in_key
บรรทัดที่ 12 ถึง 18 คำสั่ง if (in_key < 0.0) จะตรวจสอบตัวเลขที่รับเข้ามาจากคีย์บอร์ดว่ามีค่าน้อยกว่าศูนย์หรือไม่ ถ้าใช่จะเพิ่มค่า n ขึ้นทีละ 1 แต่ถ้าไม่ใช่จะไปตรวจสอบเงื่อนไข if (in_key == 0.0) คือตรวจสอบว่าตัวเลขที่รับเข้ามาจากคีย์บอร์ดว่ามีค่าเท่ากับศูนย์หรือไม่ ถ้าใช่จะเพิ่มค่า z ขึ้นทีละ 1 แต่ถ้าไม่ใช่ทั้ง 2 กรณี แสดงว่า ตัวเลขที่รับเข้ามาจากคีย์บอร์ดมีค่ามากกว่าศูนย์ ก็จะเพิ่มค่า p ขึ้นทีละ 1 หลังจากนั้นค่อยเพิ่มค่าตัวแปร c ขึ้น 1 แล้วกลับไปตรวจสอบเงื่อนไขใน loop while อีกครั้ง ซึ่งจะวนทำงานแบบนี้ไปเรื่อย ๆ
บรรทัดที่ 20 ถึง 23 เป็นคำสั่งที่โปรแกรมจะทำงานภายหลังจากตรวจสอบเงื่อนไข while แล้วเป็นเท็จ คือ แสดงจำนวนของตัวเลขที่เป็นค่าบวก ค่าลบ และ เท่ากับศูนย์ ที่บวกสะสมไว้แล้วนั้น แสดงออกจอภาพ และหยุดรอรับค่าใด ๆ จากคีย์บอร์ด เช่น ถ้ากด enter ก็จะกลับสู่โปรแกรม
4.1.3 คำสั่ง do while
do while เป็นคำสั่งที่มีการทำงานซ้ำ ๆ วนลูป คล้ายกับคำสั่ง while มาก แตกตางกันตรงที่คำสั่ง do while จะทดสอบเงื่อนไขหลังจากที่ได้ทำงานตามคำสั่งภายในลูปไปแล้ว 1 รอบ จากนั้นจึงค่อยย้อนกลับมาทดสอบเงื่อนไขอีกครั้งหนึ่ง ถ้าเงื่อนไขเป็นจริงก็จะทำงานตามคำสั่งภายในลูป แต่ถ้าเงื่อนไขเป็นเท็จจะออกจากคำสั่ง do while ทันที
รูปแบบการใช้คำสั่ง do while
do{
statement(s);
} while (expression);
ลักษณะการทำงานของคำสั่ง do while สามารถเขียนเป็นแผนผังได้ดังนี้
รูปที่ 4.3 ผังงานแสดงลักษณะการทำงานของคำสั่ง do while
ที่มา : สมชาย รัตนเลิศนุสรณ์, 2545 : 85.
ข้อควรระวังในการใช้คำสั่ง do while
ควรระวังเงื่อนไขของคำสั่ง do while ต้องพิจารณาให้ดีว่ามีทั้งกรณีที่เป็นจริงและเท็จอยู่หรือไม่ ถ้ามีอยู่ทั้ง 2 กรณี แสดงว่าใช้คำสั่งนี้ได้ถูกต้องตามไวยากรณ์ของคำสั่งนี้ ถ้ามีเฉพาะกรณีที่เงื่อนไขเป็นจริงเท่านั้นแสดงว่าเกิดลักษณะการทำงานวนลูป (looping) ไม่มีทางออกจากคำสั่งนี้ ในทำนองกลับกันถ้าเงื่อนไขเป็นเท็จอย่างเดียว จะทำคำสั่ง do while เพียงครั้งเดียว
โปรแกรมตัวอย่างที่ 4.8 แสดงการใช้คำสั่ง do while เพื่อวนลูปแสดง main memu ให้ผู้ใช้เลือกเมนู ไปเรื่อย ๆ จนกว่าเลือกเมนูที่ 5 ถึงจะออกจากโปรแกรม
/* dowhile1.c */
#include<stdio.h> /* บรรทัดที่ 1 */
#include<conio.h> /* บรรทัดที่ 2 */
void main(void) /* บรรทัดที่ 3 */
{ /* บรรทัดที่ 4 */
char choice; /* บรรทัดที่ 5 */
clrscr(); /* บรรทัดที่ 6 */
do { /* บรรทัดที่ 7 */
printf("\n\n******* MAIN MENU *******\n"); /* บรรทัดที่ 8 */
printf("*************************\n\n"); /* บรรทัดที่ 9 */
printf("1. Create New File\n"); /* บรรทัดที่ 10 */
printf("2. Use an Old File\n"); /* บรรทัดที่ 11 */
printf("3. Edit data record in File \n"); /* บรรทัดที่ 12 */
printf("4. Append data record in File\n"); /* บรรทัดที่ 13 */
printf("5. Exit Program\n"); /* บรรทัดที่ 14 */
printf("Enter your choice(1,2,3,4,5): "); /* บรรทัดที่ 15 */
choice=getche(); /* บรรทัดที่ 16 */
}while(choice != '5'); /* บรรทัดที่ 17 */
} /* บรรทัดที่ 18 */
ผลลัพธ์ที่ได้จากโปรแกรม
คำอธิบายโปรแกรม
จากโปรแกรมตัวอย่างที่ 4.8 สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ ได้ดังนี้
บรรทัดที่ 7 คำสั่ง do จะควบคุมการทำงานของโปรแกรม ให้ทำตามคำสั่งที่อยู่ภายใน loop do คือคำสั่งภายในเครื่องหมาย { } บรรทัดที่ 8 ถึง 16 ซึ่งจะทำอย่างน้อย 1 รอบ หลังจากนั้นค่อยไปตรวจสอบเงื่อนไข while ในบรรทัดที่ 17 ถ้าเป็นจริงจะกลับมาทำคำสั่งใน loop อีกครั้ง แต่ถ้าเป็นเท็จก็จะออกจากโปรแกรม และสิ้นสุดการทำงาน
บรรทัดที่ 17 คำสั่ง while (choice!=‘5‘); จะตรวจสอบค่าที่รับเข้ามาจากคีย์บอร์ด ซึ่งจะเก็บไว้ในตัวแปร choice และค่าที่รับเข้ามาจะเป็นชนิดอักขระ ตรวจสอบว่าไม่เท่ากับ ตัวอักขระ 5 จริงหรือเท็จ (‘5‘ ความหมายเป็นตัวอักขระไม่ใช่ตัวเลข ซึ่งเวลาตรวจสอบเงื่อนไข ตัวดำเนินการทางคณิตศาสตร์ ข้อมูลที่จะตรวจสอบต้องเป็นชนิดเดียวกัน) มีเงื่อนไขที่จะเป็นเท็จอยู่กรณีเดียว คือ เติม 5 จะทำให้ ‘5‘ != 5 เป็นเท็จ ก็จะออกจาก loop และจบการทำงาน
โปรแกรมตัวอย่างที่ 4.9 แสดงการใช้คำสั่ง do while เพื่อวนลูป คำนวณค่าผลบวกตัวเลข 1 ถึง 100
/* dowhile2.c */
#include <stdio.h> /* บรรทัดที่ 1 */
#include <conio.h> /* บรรทัดที่ 2 */
void main(void) /* บรรทัดที่ 3 */
{ /* บรรทัดที่ 4 */
int i=1, sum=0; /* บรรทัดที่ 5 */
clrscr(); /* บรรทัดที่ 6 */
do /* บรรทัดที่ 7 */
{ /* บรรทัดที่ 8 */
sum = sum+i; /* บรรทัดที่ 9 */
i++; /* บรรทัดที่ 10 */
} while (i<=100); /* บรรทัดที่ 11 */
printf("Sum = %d", sum); /* บรรทัดที่ 12 */
printf("\n\nPress any key back to program..."); /* บรรทัดที่ 13 */
getch(); /* บรรทัดที่ 14 */
} /* บรรทัดที่ 15 */
ผลลัพธ์ที่ได้จากโปรแกรม
คำอธิบายโปรแกรม
จากโปรแกรมตัวอย่างที่ 4.9 สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ ได้ดังนี้
บรรทัดที่ 7 คำสั่ง do จะควบคุมการทำงานของโปรแกรม ให้ทำตามคำสั่งที่อยู่ภายใน loop do คือคำสั่งภายในเครื่องหมาย { } บรรทัดที่ 9 ถึง 10 ซึ่งจะทำอย่างน้อย 1 รอบ หลังจากนั้นค่อยไปตรวจสอบเงื่อนไข while ในบรรทัดที่ 11 ถ้าเป็นจริงจะกลับมาทำคำสั่งใน loop อีกครั้ง แต่ถ้าเป็นเท็จก็จะออกจากโปรแกรม และสิ้นสุดการทำงาน
บรรทัดที่ 11 คำสั่ง while (i<=100); จะตรวจสอบว่าค่า i น้อยกว่าหรือเท่ากับ 100 เป็นจริงหรือเท็จ ถ้าเป็นจริงจะกลับไปทำงานตามคำสั่งใน loop do คือ บวกสะสมตัวเลข เก็บไว้ในตัวแปร sum แล้วเพิ่มค่า i ขึ้นทีละ 1 แต่ถ้าเป็นเท็จ คือ ค่า i เป็น 101 จะออกจาก loop do แล้วไปทำคำสั่งบรรทัดที่ 12 ถึง 14 นั่นคือ พิมพ์ค่าผลบวกสะสมตัวเลข 1 ถึง 100 แล้วพิมพ์ข้อความให้กดคีย์ใด ๆ เพื่อกลับเข้าสู่โปรแกรม และหยุดรอรับค่าใด ๆ จากคีย์บอร์ด เช่น ถ้ากด enter ก็จะกลับสู่โปรแกรม
4.1.4 คำสั่ง break
break เป็นคำสั่งที่สั่งให้ออกจากคำสั่ง for หรือ while หรือ do while หรือคำสั่ง switch (คำสั่ง switch อธิบายไว้ในหัวข้อ 2.4)
รูปแบบการใช้คำสั่ง break
break;
โปรแกรมตัวอย่างที่ 4.10 แสดงการใช้คำสั่ง break ควบคู่กับคำสั่ง for
/* break.c */
#include<stdio.h> /* บรรทัดที่ 1 */
#include<conio.h> /* บรรทัดที่ 2 */
void main(void) /* บรรทัดที่ 3 */
{ /* บรรทัดที่ 4 */
int j; /* บรรทัดที่ 5 */
clrscr(); /* บรรทัดที่ 6 */
for (j=1; j<=20; j++) { /* บรรทัดที่ 7 */
printf("%d\t",j); /* บรรทัดที่ 8 */
if (j==10) break; /* break when j==10 */ /* บรรทัดที่ 9 */
} /* end for */ /* บรรทัดที่ 10 */
printf("\n\nPress any key back to program..."); /* บรรทัดที่ 11 */
getch(); /* บรรทัดที่ 12 */
} /* บรรทัดที่ 13 */
ผลลัพธ์ที่ได้จากโปรแกรม
คำอธิบายโปรแกรม
จากโปรแกรมตัวอย่างที่ 4.10 สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ ได้ดังนี้
บรรทัดที่ 7 คำสั่ง for (j = 1; j <=20; j++) ต้องการให้โปรแกรมวนทำงานพิมพ์ค่าของตัวแปร j ตั้งแต่ 1 ถึง โดยแต่ละค่าให้ห่างกัน 1 tab
บรรทัดที่ 9 คำสั่ง if (j == 10) break; จะตรวจสอบค่าตัวแปร j ว่าเท่ากับ 10 หรือไม่ ถ้าเท่ากับ 10 ให้หยุดการทำงาน (break) และออกจาก loop for ดังนั้นโปรแกรมนี้จะไม่ได้พิมพ์ตัวเลข 1 ถึง 20 เพราะพบคำสั่ง break แต่จะพิมพ์ตัวเลข 1 ถึง 10
บรรทัดที่ 11 และ 12 เป็นคำสั่งที่จะทำงานภายหลังจากตรวจสอบเงื่อนไข for ในบรรทัดที่ 7 แล้วได้ค่าเท็จ นั่นคือ พิมพ์ข้อความให้กดคีย์ใด ๆ เพื่อกลับสู่โปรแกรม และหยุดรอรับค่าใด ๆ จากคีย์บอร์ด เช่น ถ้ากด enter ก็จะกลับสู่โปรแกรม
4.1.5 คำสั่ง continue
continue เป็นคำสั่งที่สั่งให้กลับไปทำงานที่คำสั่งแรกของลูปคำสั่ง for หรือ while หรือ do while ทำให้มีการทำงานในรอบต่อไป
รูปแบบการใช้คำสั่ง continue
continue;
โปรแกรมตัวอย่างที่ 4.11 แสดงการใช้คำสั่ง continue ควบคู่กับคำสั่ง for
/* continue.c */
#include<stdio.h> /* บรรทัดที่ 1 */
#include<conio.h> /* บรรทัดที่ 2 */
void main(void) /* บรรทัดที่ 3 */
{ /* บรรทัดที่ 4 */
int j; /* บรรทัดที่ 5 */
clrscr(); /* บรรทัดที่ 6 */
for( j=1; j<=20; j++ ){ /* บรรทัดที่ 7 */
printf("%d\t",j); /* บรรทัดที่ 8 */
if (j==5) { j=j+10; continue; } /* บรรทัดที่ 9 */
} /* บรรทัดที่ 10 */
printf("\n\nPress any key back to program..."); /* บรรทัดที่ 11 */
getch(); /* บรรทัดที่ 12 */
} /* บรรทัดที่ 13 */
ผลลัพธ์ที่ได้จากโปรแกรม
คำอธิบายโปรแกรม
จากโปรแกรมตัวอย่างที่ 4.11 สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ ได้ดังนี้
บรรทัดที่ 7 คำสั่ง for (j=1; j<=20; j++) ต้องการให้โปรแกรมวนทำงานพิมพ์ค่าของตัวแปร j ตั้งแต่ 1 ถึง 20 โดยแต่ละค่าให้ห่างกัน 1 tab
บรรทัดที่ 9 คำสั่ง if (j==5) {j=j+10; continue;} จะตรวจสอบค่าตัวแปร j ว่าเท่ากับ 5 หรือไม่ ถ้าเท่ากับ 5 ให้เพิ่มค่า j ไป 10 แล้วกลับไปทำงาน (continue) คำสั่งบรรทัดที่ 7 คือ เพิ่มค่า j อีก 1 เป็น 16 ดังนั้นโปรแกรมนี้จะไม่ได้พิมพ์ตัวเลข 1 ถึง 20 ทุกตัว แต่จะข้ามตัวเลขช่วง 6 ถึง 15 ไป
บรรทัดที่ 11 และ 12 เป็นคำสั่งที่จะทำงานภายหลังจากตรวจสอบเงื่อนไข for ในบรรทัดที่ 7 แล้วได้ค่าเท็จ นั่นคือ พิมพ์ข้อความให้กดคีย์ใด ๆ เพื่อกลับสู่โปรแกรม และหยุดรอรับค่าใด ๆ จากคีย์บอร์ด เช่น ถ้ากด enter ก็จะกลับสู่โปรแกรม
4.2 คำสั่งทดสอบเงื่อนไขเพื่อการตัดสินใจ (decision statements)
คำสั่งทดสอบเงื่อนไขเพื่อการตัดสินใจ เป็นคำสั่งที่มีการทดสอบเงื่อนไขก่อนที่จะทำงานตามคำสั่งที่กำหนดไว้ ซึ่งได้แก่คำสั่ง if, if else, โครงสร้าง else if (หรือ nested if) และคำสั่ง switch
4.2.1 คำสั่ง if
if เป็นคำสั่งที่สั่งให้มีการทดสอบเงื่อนไขก่อนที่จะไปทำงานตามคำสั่งที่กำหนดไว้
รูปแบบการใช้คำสั่ง if
if (expression) statement;
หรือ
if (expression)
{
statement(s);
}
โดยที่
expression คือ นิพจน์เงื่อนไข ซึ่งจะมีค่าจริงหรือเท็จอย่างใดอย่างหนึ่งเท่านั้น ถ้าเงื่อนไขเป็นจริง จะทำงานตามคำสั่งที่อยู่ใน if จากนั้นก็ออกจากคำสั่ง if ไปทำคำสั่งถัดไป ถ้าเงื่อนไขเป็นเท็จจะออกจากคำสั่ง if ทันที
ลักษณะการทำงานของคำสั่ง if สามารถเขียนเป็นแผนผังได้ดังนี้
รูปที่ 4.4 ผังงานแสดงลักษณะการทำงานของคำสั่ง if
ที่มา : สมชาย รัตนเลิศนุสรณ์, 2545 : 90.
โปรแกรมตัวอย่างที่ 4.12 แสดงการใช้คำสั่ง if เพื่อตรวจสอบค่าที่รับจากคีย์บอร์ด
/* if1.C. */
#include <stdio.h> /* บรรทัดที่ 1 */
#include <conio.h> /* บรรทัดที่ 2 */
#include <ctype.h> /* บรรทัดที่ 3 */
/*Capitalize Keys read from The Keyboard */ /* บรรทัดที่ 4 */
main() /* บรรทัดที่ 5 */
{ /* บรรทัดที่ 6 */
char any_char; /* บรรทัดที่ 7 */
clrscr(); /* บรรทัดที่ 8 */
printf("Please type a lowercase letter : "); /* บรรทัดที่ 9 */
scanf("%c", &any_char); /* บรรทัดที่ 10 */
if(any_char >= 'a') /* บรรทัดที่ 11 */
printf("In uppercase: %c \n", toupper(any_char)); /* บรรทัดที่ 12 */
getch(); /* บรรทัดที่ 13 */
return(0); /* บรรทัดที่ 14 */
} /* บรรทัดที่ 15 */
ผลลัพธ์ที่ได้จากโปรแกรม
คำอธิบายโปรแกรม
จากโปรแกรมตัวอย่างที่ 4.12 สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ ได้ดังนี้
บรรทัดที่ 3 #include <ctype.h> ให้การสนับสนุนฟังก์ชัน toupper( ) ในบรรทัดที่ 12
บรรทัดที่ 4 เป็นคำอธิบายโปรแกรมเพื่อบอกให้ทราบว่าเป็นโปรแกรมที่แปลงตัวอักขระที่รับเข้ามาให้เป็นตัวพิมพ์ใหญ่
บรรทัดที่ 9 และ 10 พิมพ์ข้อความแนะนำให้ผู้ใช้ พิมพ์ตัวพิมพ์เล็ก แล้วรับเข้ามาเก็บไว้ในตัวแปร any_char ตามลำดับ
บรรทัดที่ 11 คำสั่ง if (any_char >= ‘a’) ตรวจสอบอักขระที่เก็บในตัวแปร any_char ที่รับเข้ามาจากคีย์บอร์ด ว่ามีค่ามากกว่าหรือเท่ากับ ‘a‘ นั่นคือตรวจสอบว่าเป็นตัวพิมพ์เล็กหรือไม่ ถ้าใช่ให้ไปทำงานคำสั่งบรรทัดที่ 12
บรรทัดที่ 12 คำสั่งที่ให้ทำภายหลังจากตรวจสอบเงื่อนไข if แล้วได้ค่าเป็นจริง คือ เรียกใช้ฟังก์ชัน toupper( ) เพื่อแปลงตัวพิมพ์เล็กที่เก็บไว้ในตัวแปร any_char เป็นตัวพิมพ์ใหญ่ คือ toupper (any_char); แสดงออกที่จอภาพ แล้วหยุดรอรับค่าใด ๆ จากคีย์บอร์ด เช่น ถ้ากด enter ก็จะกลับสู่โปรแกรม
โปรแกรมตัวอย่างที่ 4.13 แสดงการใช้คำสั่ง if เพื่อช่วยในการนับตัวอักขระและนับคำในประโยคที่ผู้ใช้พิมพ์
/* if2.c */
#include<stdio.h> /* บรรทัดที่ 1 */
#include<conio.h> /* บรรทัดที่ 2 */
void main(void) /* บรรทัดที่ 3 */
{ /* บรรทัดที่ 4 */
int charcnt = 0, wordcnt = 0; /* บรรทัดที่ 5 */
char ch; /* บรรทัดที่ 6 */
clrscr(); /* บรรทัดที่ 7 */
printf("Type your sentense or a phrase : "); /* บรรทัดที่ 8 */
while( (ch=getche( ) ) != '\r' ) /* บรรทัดที่ 9 */
{ /* บรรทัดที่ 10 */
charcnt++; /* บรรทัดที่ 11 */
if( ch==' ' ) wordcnt++; /* บรรทัดที่ 12 */
} /* end while */ /* บรรทัดที่ 13 */
printf("\n\nCharacter count is %d", charcnt); /* บรรทัดที่ 14 */
printf("\nWord count is %d", wordcnt+1); /* บรรทัดที่ 15 */
printf("\n\nPress any key back to program..."); /* บรรทัดที่ 16 */
getch(); /* บรรทัดที่ 17 */
} /* บรรทัดที่ 18 */
ผลลัพธ์ที่ได้จากโปรแกรม
คำอธิบายโปรแกรม
จากโปรแกรมตัวอย่างที่ 4.13 สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ ได้ดังนี้
บรรทัดที่ 5 ประกาศตัวแปรชนิดจำนวนเต็ม โดยที่ charcnt ใช้เก็บจำนวนตัวอักขระที่นับได้ และ wordcnt ใช้เก็บจำนวนคำที่นับได้ในประโยค
บรรทัดที่ 9 คำสั่ง while ((ch = getche()) ! = ‘ \r ‘) เพื่อควบคุมการทำงานของโปรแกรมให้วนทำงานซ้ำ ๆ จนกว่าเงื่อนไขเป็นเท็จจึงหยุด นั่นคือ ถ้าผู้ใช้กด enter แทนการเติมประโยค จะทำให้เป็นเท็จ แล้วจะออกจาก loop while ไปทำคำสั่งบรรทัดที่ 14 ถึง 17 แต่ถ้าเป็นจริง คือ ผู้ใช้เติมประโยค ก็จะทำงานใน loop while บรรทัดที่ 11 และ 12
บรรทัดที่ 11 คำสั่ง charcnt ++; ให้บวกสะสมตามจำนวนตัวอักขระที่ผู้ใช้พิมพ์รวมทั้งช่องว่างก็นับด้วย
บรรทัดที่ 12 คำสั่ง if (ch == ‘ ‘) wordcnt ++ เพื่อตรวจสอบว่าตัวแปร ch เท่ากับช่องว่างหรือไม่ นั่นคือ ผู้ใช้เคาะแป้นพิมพ์ที่ space bar เพื่อเว้นช่องว่างกี่ครั้ง จะบวกสะสมไว้ที่ตัวแปร wordcnt
บรรทัดที่ 14 พิมพ์แสดงจำนวนตัวอักขระที่นับสะสมไว้ในตัวแปร charcnt ออกจอภาพ
บรรทัดที่ 15 พิมพ์แสดงจำนวนคำที่นับสะสมไว้ในตัวแปร wordcnt ออกจอภาพ แต่ตัวแปร wordcnt ต้องเพิ่มอีก 1 เพราะถึงจะเป็นจำนวนคำที่ถูกต้อง
บรรทัดที่ 16 และ 19 พิมพ์ข้อความให้กดคีย์ใด ๆ เพื่อกลับสู่โปรแกรม และ หยุดรอรับค่าใด ๆ จากคีย์บอร์ด เช่น ถ้ากด enter ก็จะกลับสู่โปรแกรม ตามลำดับ
4.2.2 คำสั่ง if else
if else เป็นคำสั่งที่สั่งให้มีการทดสอบเงื่อนไข โดยมีการตัดสินใจแบบ 2 ทางเลือก
รูปแบบการใช้คำสั่ง if else
if (expression) {
statementA(s);
}
else {
statementB(s);
}
จากรูปแบบการใช้คำสั่ง if else หมายความว่า ถ้านิพจน์เงื่อนไข (expression) มีค่าเป็นจริงจะทำตามคำสั่งชุด A (statementA(s);) ถ้ามีค่าเป็นเท็จจะทำตามคำสั่งชุด B (statementB(s);) เมื่อทำเสร็จก็ออกจากคำสั่งนี้
ลักษณะการทำงานของคำสั่ง if else สามารถเขียนเป็นแผนผังได้ดังนี้
รูปที่ 4.5 ผังงานแสดงลักษณะการทำงานของคำสั่ง if else
ที่มา : สมชาย รัตนเลิศนุสรณ์, 2545 : 92.
โปรแกรมตัวอย่างที่ 4.14 แสดงการใช้คำสั่ง if else เพื่อตรวจสอบค่าที่รับจากคีย์บอร์ด
/* if_else1.c */
#include <stdio.h> /* บรรทัดที่ 1 */
#include <conio.h> /* บรรทัดที่ 2 */
#include <ctype.h> /* บรรทัดที่ 3 */
/*Capitalize Keys read from The Keyboard */ /* บรรทัดที่ 4 */
main() /* บรรทัดที่ 5 */
{ /* บรรทัดที่ 6 */
char any_char; /* บรรทัดที่ 7 */
clrscr(); /* บรรทัดที่ 8 */
printf("Please type a lowercase letter : "); /* บรรทัดที่ 9 */
scanf("%c",&any_char); /* บรรทัดที่ 10 */
if(any_char < 'a') /* บรรทัดที่ 11 */
printf("Sorry, I can not capitalize that.\n"); /* บรรทัดที่ 12 */
else /* บรรทัดที่ 13 */
printf("Thank you. In uppercase : %c.",toupper (any_char)); /* บรรทัดที่ 14 */
printf("\n\nPress any key back to program..."); /* บรรทัดที่ 15 */
getch(); /* บรรทัดที่ 16 */
return(0); /* บรรทัดที่ 17 */
} /* บรรทัดที่ 18 */
ผลลัพธ์ที่ได้จากโปรแกรม
กรณีที่เติมตัวอักษรพิมพ์เล็ก
กรณีที่เติมตัวอักษรพิมพ์ใหญ่
คำอธิบายโปรแกรม
จากโปรแกรมตัวอย่างที่ 4.14 สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ ได้ดังนี้
บรรทัดที่ 11 และ 12 คำสั่ง if (any_char < ‘a’) ตรวจสอบอักขระที่รับเข้ามาว่ามีค่าน้อยกว่า ‘a’ หรือไม่ ถ้าใช่ให้พิมพ์ข้อความ Sorry, I can not capitalize that. นั่นคือตรวจสอบตัวอักขระที่รับเข้ามาว่าใช่ตัวอักขระพิมพ์ใหญ่หรือไม่ แต่ถ้าไม่ใช่ ให้ไปทำคำสั่งบรรทัดที่ 13
บรรทัดที่ 13 else คือ เงื่อนไขบรรทัดที่ 11 เป็นเท็จ (กรณีที่ตัวอักขระเป็นตัวพิมพ์เล็ก) ให้ทำคำสั่งบรรทัดที่ 14 คือ เปลี่ยนตัวพิมพ์เล็กให้เป็นตัวพิมพ์ใหญ่ ด้วยฟังก์ชัน toupper( ) และ แสดงออกจอภาพ
บรรทัดที่ 15 และ 16 พิมพ์ข้อความให้กดคีย์ใด ๆ เพื่อกลับสู่โปรแกรม และหยุดรอรับค่าใด ๆ จากคีย์บอร์ด เช่น ถ้ากด enter ก็จะกลับสู่โปรแกรม ตามลำดับ
โปรแกรมตัวอย่างที่ 4.15 แสดงการใช้คำสั่ง if else เพื่อเปรียบเทียบค่าตัวเลขที่ผู้ใช้เติม
/* if_else2.c */
#include<stdio.h> /* บรรทัดที่ 1 */
#include<conio.h> /* บรรทัดที่ 2 */
void main(void) /* บรรทัดที่ 3 */
{ /* บรรทัดที่ 4 */
int x, y; char ch; /* บรรทัดที่ 5 */
clrscr( ); /* บรรทัดที่ 6 */
printf("Enter an integer of X : "); /* บรรทัดที่ 7 */
scanf("%d",&x); /* บรรทัดที่ 8 */
printf("Enter an integer of Y : "); /* บรรทัดที่ 9 */
scanf("%d",&y); ch=getchar( ); /* บรรทัดที่ 10 */
if ( x==y ) /* บรรทัดที่ 11 */
printf("\nX equal to Y = %d\n",x); /* บรรทัดที่ 12 */
else /* บรรทัดที่ 13 */
printf("\nX = %d not equal to Y= %d\n",x,y); /* บรรทัดที่ 14 */
printf("\n\nPress any key back to program..."); /* บรรทัดที่ 15 */
getch(); /* บรรทัดที่ 16 */
} /* บรรทัดที่ 17 */
ผลลัพธ์ที่ได้จากโปรแกรม
กรณีที่เติมตัวเลข 2 ตัวเท่ากัน
กรณีที่เติมตัวเลข 2 ตัวไม่เท่ากัน
คำอธิบายโปรแกรม
จากโปรแกรมตัวอย่างที่ 4.15 สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ ได้ดังนี้
บรรทัดที่ 7 และ 8 ให้ผู้ใช้เติมตัวเลขจำนวนเต็ม แล้วเก็บไว้ที่ตัวแปร x ตามลำดับ
บรรทัดที่ 9 และ 10 ให้ผู้ใช้เติมตัวเลขจำนวนเต็ม แล้วเก็บไว้ที่ตัวแปร y ตามลำดับ
บรรทัดที่ 11 if (x == y) ทดสอบเงื่อนไขโดยการนำค่าตัวแปร x และ y เปรียบเทียบกันว่าเท่ากันจริงหรือเท็จ ถ้าจริง จะทำคำสั่งบรรทัดที่ 12 คือให้พิมพ์บอกว่า x เท่ากับ y และพิมพ์ค่า x แสดงที่จอภาพ
บรรทัดที่ 13 else ถ้าเงื่อนไขบรรทัดที่ 11 เป็นเท็จ จะมาทำคำสั่งบรรทัดที่ 13 และ 14 คือ พิมพ์บอกว่า x ไม่เท่ากับ y พร้อมทั้งพิมพ์ค่า ตัวแปร x และ y แสดงที่จอภาพ
บรรทัดที่ 15 และ 16 พิมพ์ข้อความให้กดคีย์ใด ๆ เพื่อกลับสู่โปรแกรม และหยุดรอรับค่าใด ๆ จากคีย์บอร์ด เช่น ถ้ากด enter ก็จะกลับสู่โปรแกรม ตามลำดับ
4.2.3 คำสั่งโครงสร้าง else if (คำสั่ง nested if)
else if เป็นโครงสร้างที่ทำให้เราสามารถใช้คำสั่ง if else ซ้อนกันได้เรื่อย ๆ ส่วนมากจะใช้ในการตัดสินใจที่มากกว่า 2 ทางเลือกขึ้นไป บางครั้งอาจเรียกโครงสร้างนี้ว่า nested if
รูปแบบการใช้โครงสร้าง nested if หรือ else if
else if (expression) {
statementA(s);
}
else if (expression){
statementB(s);
}
else if (expression){
……..
ข้อควรระวังในการใช้ nested if
การเขียนคำสั่ง nested if ค่อนข้างยุ่งยาก อาจเกิดความสับสนได้ ควรเขียนคำสั่ง nested if ให้เยื้องกันเพื่อความสะดวกในการแก้ไขคำสั่งในภายหลัง
โปรแกรมตัวอย่างที่ 4.16 แสดงการใช้คำสั่ง nested if เพื่อตรวจสอบคะแนนที่ผู้ใช้เติม แล้วให้เกรดตามเงื่อนไขที่กำหนดในโปรแกรม
/* nestif1.c */
#include<stdio.h> /* บรรทัดที่ 1 */
#include<conio.h> /* บรรทัดที่ 2 */
#include<stdlib.h> /* บรรทัดที่ 3 */
void main(void) /* บรรทัดที่ 4 */
{ /* บรรทัดที่ 5 */
int score, n, i; /* บรรทัดที่ 6 */
char grade; /* บรรทัดที่ 7 */
char numstr[20]; /* บรรทัดที่ 8 */
clrscr( ); /* บรรทัดที่ 9 */
printf("Enter Number of Students : "); /* บรรทัดที่ 10 */
n = atoi(gets(numstr)); /* บรรทัดที่ 11 */
for ( i=1; i<=n; i++ ){ /* บรรทัดที่ 12 */
printf("\nEnter score of student #%d : ", i); /* บรรทัดที่ 13 */
score = atoi(gets(numstr)); /* บรรทัดที่ 14 */
if ( score >= 80 ) /* บรรทัดที่ 15 */
grade = 'A'; /* บรรทัดที่ 16 */
else if ( score >= 70 ) /* บรรทัดที่ 17 */
grade = 'B'; /* บรรทัดที่ 18 */
else if ( score >= 60 ) /* บรรทัดที่ 19 */
grade = 'C'; /* บรรทัดที่ 20 */
else if ( score >= 50 ) /* บรรทัดที่ 21 */
grade = 'D'; /* บรรทัดที่ 22 */
else grade = 'F'; /* บรรทัดที่ 23 */
printf("Score = %d, Grade of std #%d is %c\n",score,i,grade); /* บรรทัดที่ 24 */
} /* end for */ /* บรรทัดที่ 25 */
printf("\n\nPress any key back to program..."); /* บรรทัดที่ 26 */
getch(); /* บรรทัดที่ 27 */
} /* บรรทัดที่ 28 */
ผลลัพธ์ที่ได้จากโปรแกรม
คำอธิบายโปรแกรม
จากโปรแกรมตัวอย่างที่ 4.16 สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ ได้ดังนี้
บรรทัดที่ 3 #include <stdlib.h> สนับสนุนการใช้ฟังก์ชัน atoi( ) ของคำสั่งบรรทัดที่ 11
บรรทัดที่ 10 และ 11 รับค่าตัวเลขที่เป็นจำนวนนักเรียน แล้วทำคำสั่ง n = atoi(gets(numstr)); คือนำค่าที่รับเข้ามาแปลงให้เป็นจำนวนเต็มแล้วเก็บไว้ที่ตัวแปร n
บรรทัดที่ 12 คำสั่ง for (i=1; i<=n; i++) เพื่อควบคุมการทำงานของโปรแกรมให้วนรอบทำงานตามจำนวนของตัวเลขที่เติมคือ n ครั้ง ซึ่งถ้าตรวจสอบเงื่อนไข for แล้วเป็นจริงจะทำคำสั่งภายใน loop for คือคำสั่งบรรทัดที่ 13 ถึง 24 แต่ถ้าตรวจสอบเงื่อนไข for แล้วเป็นเท็จ จะไปทำคำสั่งบรรทัดที่ 26 และ 27
บรรทัดที่ 13 และ 14 รับค่าคะแนนที่ผู้ใช้เติม แล้วแปลงให้เป็นจำนวนเต็มเก็บไว้ที่ตัวแปร score ตามลำดับ
บรรทัดที่ 15 คำสั่ง if ( score >= 80 ) ตรวจสอบเงื่อนไขของตัวแปร score ว่ามากกว่าหรือเท่ากับ 80 หรือไม่ ถ้าใช่ให้กำหนดตัวแปร grade เก็บ A แต่ถ้าไม่ใช่ให้ไปทำงานคำสั่งบรรทัดที่ 17
บรรทัดที่ 17 คำสั่ง else if ( score >= 70 ) ตรวจสอบเงื่อนไขต่ออีกว่าตัวแปร score ว่ามากกว่าหรือเท่ากับ 70 หรือไม่ ถ้าใช่ให้กำหนดตัวแปร grade เก็บ B แต่ถ้าไม่ใช่ให้ไปทำงานคำสั่งบรรทัดที่ 19
บรรทัดที่ 19 คำสั่ง else if ( score >= 60 ) ตรวจสอบเงื่อนไขต่ออีกว่าตัวแปร score ว่ามากกว่าหรือเท่ากับ 60 หรือไม่ ถ้าใช่ให้กำหนดตัวแปร grade เก็บ C แต่ถ้าไม่ใช่ให้ไปทำงานคำสั่งบรรทัดที่ 21
บรรทัดที่ 21 คำสั่ง else if ( score >= 50 ) ตรวจสอบเงื่อนไขต่ออีกว่าตัวแปร score ว่ามากกว่าหรือเท่ากับ 50 หรือไม่ ถ้าใช่ให้กำหนดตัวแปร grade เก็บ D แต่ถ้าไม่ใช่ให้ไปทำงานคำสั่งบรรทัดที่ 23
บรรทัดที่ 23 คำสั่ง else grade = ‘F’; กำหนดตัวแปร grade เก็บ F
บรรทัดที่ 24 ภายหลังจากทำงานทุกเงื่อนไขแล้วจะมาทำคำสั่งบรรทัดที่ 24 คือ แสดงค่าตัวแปร score ตัวแปร i และตัวแปร grade ที่ได้แสดงออกจอภาพ
บรรทัดที่ 26 และ 27 พิมพ์ข้อความให้กดคีย์ใด ๆ เพื่อกลับสู่โปรแกรม สุดท้ายจะหยุดรอรับค่าใด ๆ จากคีย์บอร์ด เช่น ถ้ากด enter ก็จะกลับสู่โปรแกรม ตามลำดับ
โปรแกรมตัวอย่างที่ 4.17 แสดงการใช้คำสั่ง nested if เพื่อเขียนเส้นทะแยงมุมในกรอบสี่เหลี่ยมพื้นสีเทา
/* nestif2.c */
/* Prints two diagonal lines on screen */
#include <stdio.h> /* บรรทัดที่ 1 */
#include <conio.h> /* บรรทัดที่ 2 */
#include <dos.h> /* บรรทัดที่ 3 */
void main(void) /* บรรทัดที่ 4 */
{ /* บรรทัดที่ 5 */
int x, y; /* บรรทัดที่ 6 */
clrscr(); /* บรรทัดที่ 7 */
printf("\n"); /* บรรทัดที่ 8 */
for (y=1; y<24; y++) /* บรรทัดที่ 9 */
{ /* บรรทัดที่ 10 */
for (x=1; x<24; x++) /* บรรทัดที่ 11 */
if ( x == y ) /* บรรทัดที่ 12 */
printf("\xDB"); /* บรรทัดที่ 13 */
else /* บรรทัดที่ 14 */
if ( x == 24 - y ) /* บรรทัดที่ 15 */
printf("\xDB"); /* บรรทัดที่ 16 */
else /* บรรทัดที่ 17 */
printf("\xB0"); /* บรรทัดที่ 18 */
printf("\n"); /* บรรทัดที่ 19 */
delay(200); /* บรรทัดที่ 20 */
} /* บรรทัดที่ 21 */
printf("\n\nPress any key back to program..."); /* บรรทัดที่ 22 */
getche(); /* บรรทัดที่ 23 */
} /* บรรทัดที่ 24 */
ผลลัพธ์ที่ได้จากโปรแกรม
คำอธิบายโปรแกรม
จากโปรแกรมตัวอย่างที่ 4.17 สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ ได้ดังนี้
บรรทัดที่ 3 #include <dos.h> สนับสนุนฟังก์ชัน delay( ) ในคำสั่งบรรทัดที่ 20
บรรทัดที่ 9 คำสั่ง for (y=1; y<24; y++) เพื่อควบคุมการทำงานของโปรแกรมให้ทำงานแถวที่ 1 ถึง แถวที่ 23 ซึ่งถ้าตรวจสอบเงื่อนไข for เป็นจริงจะทำคำสั่งบรรทัดที่ 11 ถึง 20 แต่ถ้าเงื่อนไขเป็นเท็จ จะทำคำสั่งบรรทัดที่ 22 และ 23
บรรทัดที่ 11 คำสั่ง for (x=1; x<24; x++) เพื่อควบคุมการทำงานของโปรแกรมให้ทำงานคอลัมน์ที่ 1 ถึง คอลัมน์ที่ 23
บรรทัดที่ 12 คำสั่ง if (x==y) ตรวจสอบเงื่อนไข ถ้าค่าตัวแปร x เท่ากับ ค่าตัวแปร y ถ้าเป็นจริงให้ทำคำสั่งบรรทัดที่ 13 printf (“\xDB”); คือให้พิมพ์อักขระกราฟฟิกรูป ออกแสดงที่จอภาพ (x==y จะได้เส้นทะแยงมุม) แต่ถ้า x ไม่เท่ากับ y คือเป็นเท็จ ให้ตรวจสอบเงื่อนไขถัดไป คือคำสั่งบรรทัดที่ 14 และ 15
บรรทัดที่ 14 และ 15 else if (x == 24 – y) ตรวจสอบเงื่อนไขต่ออีกว่า ตัวแปร x==24-y หรือไม่ ถ้าใช่ ให้ทำคำสั่งบรรทัดที่ 16 printf (“\xDB”); คือให้พิมพ์อักขระกราฟฟิกรูป เส้นทะแยงมุมจากมุมบนขวาสุดไปยังมุมล่างซ้ายสุด แต่ถ้าไม่ใช่ ให้ไปตรวจสอบเงื่อนไขถัดไป คือคำสั่งบรรทัดที่ 17 และ 18
บรรทัดที่ 17 และ 18 ถ้าไม่เป็นไปตามเงื่อนไขดังที่กล่าวมาข้างต้น ให้พิมพ์อักขระกราฟฟิกรูป สีเทา แสดงที่จอภาพ
บรรทัดที่ 19 ภายหลังจากทำงานทุกเงื่อนไขแล้ว จะทำคำสั่งบรรทัดที่ 19 คือ ขึ้นบรรทัดใหม่ และ ทำคำสั่งบรรทัดที่ 20
บรรทัดที่ 20 คำสั่ง delay (200); คือ ขณะที่วาดรูปอักขระกราฟฟิก แต่ละครั้งให้หน่วงเวลาด้วย
บรรทัดที่ 22 และ 23 พิมพ์ข้อความให้กดคีย์ใด ๆ เพื่อกลับสู่โปรแกรม สุดท้ายจะหยุดรอรับค่าใด ๆ จากคีย์บอร์ด เช่น ถ้ากด enter ก็จะกลับสู่โปรแกรม ตามลำดับ
4.2.4 คำสั่ง switch
switch เป็นคำสั่งที่ใช้ทดสอบเงื่อนไขในกรณีที่มีทางเลือกสำหรับตัดสินใจมากกว่า 2 ทางขึ้นไปเช่นเดียวกันกับ nested if โดยมากนิยมใช้คำสั่ง switch แทนคำสั่ง nested if เพราะมีรูปแบบการใช้คำสั่งที่ง่ายและสะดวกในการแก้ไขคำสั่งเมื่อมีข้อผิดพลาดเกิดขึ้น
รูปแบบการใช้คำสั่ง switch
switch (expression) {
case expression1:
statement(s); break;
case expression2:
statement(s); break;
…..
case expressionN:
statement(s); break;
default:
statement(s);
}
โดยที่
expression คือ นิพจน์ หรือตัวแปรที่จะใช้เปรียบเทียบกับนิพจน์ expression1, expression2, …, expressionN ว่ามีค่าตรงกับนิพจน์ใด
expression1, expression2, …, expressionN คือ นิพจน์ หรือค่าคงที่ในเงื่อนไขที่ 1, 2, 3, …, N ตามลำดับ
break คือ คำสั่งที่จะต้องใส่ไว้ในแต่ละ case เพื่อเป็นการบอกให้ออกจากคำสั่ง switch หลังจากทำคำสั่งที่อยู่ใน case นั้น ๆ แล้ว ถ้าหากไม่มีคำสั่ง break ใน case ใด เมื่อทำงานจบ case นั้นแล้ว จะทำงานใน case ถัดไปจนกว่าจะเจอคำสั่ง break ซึ่งทำให้เกิดการทำงานผิดพลาดได้
default คือ กรณีที่ expression ไม่ตรงกับเงื่อนไขใด ๆ เลย ให้ทำงานตามคำสั่งที่เขียนไว้ใน default โดย default นี้ไม่จำเป็นต้องใส่คำสั่ง break เอาไว้ เพราะ default เป็นกรณีสุดท้ายของคำสั่ง switch
ข้อควรระวังในการใช้คำสั่ง switch
1) ถ้าใช้คำสั่ง switch ในแต่ละกรณี (case) จะต้องใส่คำสั่ง break เอาไว้ด้วยมิฉะนั้นจะเกิดการทำงานซ้ำใน case ต่อมาจนกว่าจะเจอคำสั่ง break ยกเว้นกรณี default ไม่ต้องใส่คำสั่ง break
2) expression ที่อยู่หลังคำสั่ง switch ควรใช้เป็นตัวแปร เพื่อจะได้สะดวกในการนำไปเปรียบเทียบกับกรณีต่าง ๆ ส่วน expression1, expression2, …, expressionN ที่อยู่หลัง case ต่าง ๆ ควรใช้เป็นค่าคงที่
โปรแกรมตัวอย่างที่ 4.18 แสดงการใช้คำสั่ง switch เพื่อตรวจสอบเกรดที่ผู้ใช้เติม ว่าตรงกับกรณีใด แล้วแสดงเกรดที่เป็นตัวเลขออกจอภาพ
/* switch.c */
#include<stdio.h> /* บรรทัดที่ 1 */
#include<conio.h> /* บรรทัดที่ 2 */
#include<stdlib.h> /* บรรทัดที่ 3 */
#include<ctype.h> /* บรรทัดที่ 4 */
void main(void) /* บรรทัดที่ 5 */
{ /* บรรทัดที่ 6 */
int n, i; /* บรรทัดที่ 7 */
float gradepoint; /* บรรทัดที่ 8 */
char grade; /* บรรทัดที่ 9 */
char numstr[20]; /* บรรทัดที่ 10 */
clrscr( ); /* บรรทัดที่ 11 */
printf("Enter Number of Students : "); /* บรรทัดที่ 12 */
n = atoi(gets(numstr)) ; /* บรรทัดที่ 13 */
for ( i=1; i<=n; i++ ) { /* บรรทัดที่ 14 */
printf("\nEnter grade of student #%d: ", i); /* บรรทัดที่ 15 */
grade = getche( ); /* บรรทัดที่ 16 */
switch(toupper(grade)) { /* บรรทัดที่ 17 */
case 'A': /* บรรทัดที่ 18 */
gradepoint = 4.0; break; /* บรรทัดที่ 19 */
case 'B': /* บรรทัดที่ 20 */
gradepoint = 3.0; break; /* บรรทัดที่ 21 */
case 'C': /* บรรทัดที่ 22 */
gradepoint = 2.0; break; /* บรรทัดที่ 23 */
case 'D': /* บรรทัดที่ 24 */
gradepoint = 1.0; break; /* บรรทัดที่ 25 */
default: gradepoint = 0.0; /* บรรทัดที่ 26 */
} /* end switch */ /* บรรทัดที่ 27 */
printf("\nGrade Point of Student#%d is %.2f\n",i,gradepoint); /* บรรทัดที่ 28 */
} /* end for */ /* บรรทัดที่ 29 */
printf("\n\nPress any key back to program..."); /* บรรทัดที่ 30 */
getch(); /* บรรทัดที่ 31 */
} /* end main */ /* บรรทัดที่ 32 */
ผลลัพธ์ที่ได้จากโปรแกรม
คำอธิบายโปรแกรม
จากโปรแกรมตัวอย่างที่ 4.18 สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ ได้ดังนี้
บรรทัดที่ 12 และ 13 ให้ผู้ใช้เติมจำนวนนักเรียน แล้วนำค่าที่ผู้ใช้เติมมาแปลงให้เป็นจำนวนเต็ม แล้วเก็บไว้ที่ตัวแปร n
บรรทัดที่ 14 for (i = 1; i < n; i++) คำสั่งควบคุมการทำงานของโปรแกรมให้วนทำงานจำนวนรอบเท่ากับตัวแปร n หรือค่าตัวเลขที่ผู้ใช้เติม เมื่อทดสอบเงื่อนไข for แล้วเป็นจริง จะทำงานตามคำสั่งใน loop for คือ คำสั่งบรรทัดที่ 15 ถึง 29 แต่ถ้าเป็นเท็จ จะไปทำงานตามคำสั่งบรรทัดที่ 30 และ 31
บรรทัดที่ 15 และ 16 ให้ผู้ใช้เติมเกรดแล้วเก็บไว้ที่ตัวแปร grade
บรรทัดที่ 17 ถึง 27 เป็น loop ของ คำสั่ง switch ซึ่งทำงานซ้อนภายใน loop for ดังนี้ จากตัวแปรเกรดที่รับเข้าจะแปลงให้เป็นตัวพิมพ์ใหญ่ทุกครั้ง เพื่อนำไปทดสอบทุกกรณีของคำสั่ง switch เริ่มตรวจสอบกรณีแรก คือ ทดสอบว่าเป็นตัว A หรือไม่ ถ้าใช่ กำหนดตัวแปร gradepoint มีค่าเท่ากับ 4.0 แล้วหยุดการทำงานในกรณีนี้ (break) แต่ถ้าไม่ใช่ตัว A ก็ไปตรวจสอบกรณีถัดไป คือ ใช่ตัว B หรือไม่ ถ้าใช่ กำหนดตัวแปร gradepoint มีค่าเท่ากับ 3.0 แล้วหยุดการทำงานในกรณีนี้ (break) แต่ถ้าไม่ใช่ตัว B ก็ไปตรวจสอบกรณีถัดไป คือ ใช่ตัว C หรือไม่ ถ้าใช่ กำหนดตัวแปร gradepoint มีค่าเท่ากับ 2.0 แล้วหยุดการทำงานในกรณีนี้ (break) แต่ถ้าไม่ใช่ตัว C ก็ไปตรวจสอบกรณีถัดไป คือ ใช่ตัว D หรือไม่ ถ้าใช่ กำหนดตัวแปร gradepoint มีค่าเท่ากับ 1.0 แล้วหยุดการทำงานในกรณีนี้ (break) กรณีสุดท้าย คือ กรณีที่เติมตัวอื่นที่ไม่ใช่ทั้ง 4 กรณีข้างต้น จะทำคำสั่งบรรทัดที่ 26 คือ default; gradepoint = 0.0; คือ กรณีอื่น ๆ ให้กำหนดตัวแปร gradepoint มีค่าเท่ากับ 0.0
บรรทัดที่ 28 ภายหลังจากการทำงานทุกกรณีของคำสั่ง switch แล้ว จะทำคำสั่งบรรทัดที่ 28 คือ แสดงค่าตัวแปร gradepoint ที่ได้ของแต่ละคน แสดงที่จอภาพ
บรรทัดที่ 30 และ 31 พิมพ์ข้อความให้กดคีย์ใด ๆ เพื่อกลับสู่โปรแกรม สุดท้ายจะหยุดรอรับค่าใด ๆ จากคีย์บอร์ด เช่น ถ้ากด enter ก็จะกลับสู่โปรแกรม ตามลำดับ
4.3 คำสั่งที่สั่งให้ไปทำงานตามจุดที่กำหนดไว้ (goto statements)
คำสั่งที่สั่งให้ไปทำงานตามจุดที่กำหนดไว้ ส่วนมากเราไม่นิยมใช้กันเพราะทำให้การตรวจสอบการทำงานของโปรแกรมทำได้ยากขึ้น เนื่องจากการใช้คำสั่ง goto และ label ทำให้การทำงานของโปรแกรมมีลักษณะกระโดดไปทำงานตามจุดที่กำหนดไว้ ทำให้การทำงานของโปรแกรมไม่ได้ทำงานจากด้านบนลงมาด้านล่างอาจเกิดความสับสนในการทำงานของโปรแกรมได้
4.3.1 คำสั่ง goto และ label
goto เป็นคำสั่งที่สั่งให้ไปทำงาน ณ จุดที่เรากำหนด โดยจะต้องตั้งเป็นชื่อ label ไว้
รูปแบบการใช้คำสั่ง goto และ label
goto labelname;
และ
labelname:
โดยที่
labelname คือ ชื่อ label ที่ตั้งขึ้นเพื่อให้โปรแกรมทำงาน
หมายเหตุ
ควรหลีกเลี่ยงการใช้คำสั่ง goto และ label เพราะจะทำให้โปรแกรมย้ายไปทำงานในตำแหน่งต่าง ๆ ทำให้เกิดความสับสนในการตรวจสอบการทำงานของโปรแกรมได้
เพื่อความเข้าใจการใช้คำสั่ง goto และ label มากยิ่งขึ้นควรศึกษาโปรแกรมตัวอย่างต่อไปนี้
โปรแกรมตัวอย่างที่ 4.19 แสดงการใช้คำสั่ง goto และ label เพื่อกำหนดให้โปรแกรมทำงานตามชื่อ label ที่กำหนด
/* gotolabe.c */
#include<stdio.h> /* บรรทัดที่ 1 */
#include<conio.h> /* บรรทัดที่ 2 */
void main(void) /* บรรทัดที่ 3 */
{ /* บรรทัดที่ 4 */
int i, j, k; /* บรรทัดที่ 5 */
j = i = 2 ; /* บรรทัดที่ 6 */
clrscr( ); /* บรรทัดที่ 7 */
loop: k = i*j; /* บรรทัดที่ 8 */
printf("%d\t %d\t %d\n", j, i++, k); /* บรรทัดที่ 9 */
if (i<7) /* บรรทัดที่ 10 */
goto loop; /* บรรทัดที่ 11 */
else /* บรรทัดที่ 12 */
goto quit; /* บรรทัดที่ 13 */
quit: printf("\nThank You !"); /* บรรทัดที่ 14 */
printf("\n\nPress any key back to program..."); /* บรรทัดที่ 15 */
getch(); /* บรรทัดที่ 16 */
} /* end main */ /* บรรทัดที่ 17 */
ผลลัพธ์ที่ได้จากโปรแกรม
คำอธิบายโปรแกรม
จากโปรแกรมตัวอย่างที่ 4.19 สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ ได้ดังนี้
บรรทัดที่ 8 และ 14 คำสั่ง loop : และ quit : คือ การกำหนดชื่อ label ชื่อว่า loop และ quit ตามลำดับ
บรรทัดที่ 11 คำสั่ง goto loop; เพื่อกำหนดให้โปรแกรมไปทำงานยัง label ที่ชื่อว่า loop ในกรณีที่คำสั่ง if (i < 7) ในบรรทัดที่ 10 เป็นจริง แต่ถ้าเป็นเท็จ จะไปทำคำสั่งบรรทัดที่ 12 และ 13
บรรทัดที่ 12 และ 13 ในกรณีที่คำสั่ง if บรรทัดที่ 10 เป็นเท็จจะมาทำงานที่คำสั่งบรรทัดที่ 13 คือ goto quit; เป็นการกำหนดให้โปรแกรมไปทำงานยัง label ที่ชื่อว่า quit
บรรทัดที่ 14 คำสั่ง quit : printf (“ \n Thank You ! “); คือ label ที่มีชื่อ quit ซึ่ง label นี้จะพิมพ์คำว่า Thank You ! แสดงที่จอภาพ
บรรทัดที่ 15 และ 16 ภายหลังจากทำงานข้างต้นที่กล่าวมาแล้ว โปรแกรมจะพิมพ์ข้อความให้กดคีย์ใด ๆ เพื่อกลับสู่โปรแกรม สุดท้ายจะหยุดรอรับค่าใด ๆ จากคีย์บอร์ด เช่น ถ้ากด enter ก็จะกลับสู่โปรแกรม ตามลำดับ
4.4 สรุปท้ายบท
สำหรับคำสั่งควบคุมการทำงานของโปรแกรม สามารถแบ่งกลุ่มตามลักษณะการทำงานตามข้อกำหนดมาตรฐานของสถาบัน ANSI (American National Standards Institute) กำหนดให้ภาษา C มีคำสั่งที่ใช้ควบคุมการทำงานของโปรแกรมดังนี้
คำสั่งวนลูปหรือทำงานซ้ำ ๆ เป็นลูป (loop statements) ได้แก่คำสั่งต่อไปนี้
คำสั่ง for เป็นคำสั่งที่สั่งให้โปแกรมมีการทำงานซ้ำ ๆ วนลูปจนกว่าเงื่อนไขที่กำหนดไว้เป็นเท็จ จึงออกจากคำสั่ง for ไปทำคำสั่งถัดไป ควรใช้คำสั่ง for ในกรณีที่ทราบจำนวนรอบของการทำงาน
คำสั่ง while เป็นคำสั่งที่มีการทำงานซ้ำ ๆ เป็นลูป และมีลักษณะการทำงานของคำสั่งคล้ายกับคำสั่ง for แตกต่างกันตรงที่ การใช้ while ไม่ต้องทราบจำนวนรอบของการทำงานที่แน่นอน แต่ต้องมีเงื่อนไขที่เป็นเท็จจึงจะออกจากคำสั่ง while ได้
คำสั่ง do while เป็นคำสั่งที่มีการทำงานซ้ำ ๆ วนลูป คล้ายกับคำสั่ง while มาก แตกตางกันตรงที่คำสั่ง do while จะทดสอบเงื่อนไขหลังจากที่ได้ทำงานตามคำสั่งภายในลูปไปแล้ว 1 รอบ จากนั้นจึงค่อยย้อนกลับมาทดสอบเงื่อนไขอีกครั้งหนึ่ง ถ้าเงื่อนไขเป็นจริงก็จะทำงานตามคำสั่งภายในลูป แต่ถ้าเงื่อนไขเป็นเท็จจะออกจากคำสั่ง do while ทันที
คำสั่ง break เป็นคำสั่งที่สั่งให้ออกจากคำสั่ง for หรือ while หรือ do while หรือคำสั่ง switch
คำสั่ง continue เป็นคำสั่งที่สั่งให้กลับไปทำงานที่คำสั่งแรกของลูปคำสั่ง for หรือ while หรือ do while ทำให้มีการทำงานในรอบต่อไป
คำสั่งทดสอบเงื่อนไขในการตัดสินใจ (decision statements) ได้แก่คำสั่งต่อไปนี้
คำสั่ง if เป็นคำสั่งที่สั่งให้มีการทดสอบเงื่อนไขก่อนที่จะไปทำงานตามคำสั่งที่กำหนดไว้
คำสั่ง if else เป็นคำสั่งที่สั่งให้มีการทดสอบเงื่อนไข โดยมีการตัดสินใจแบบ 2 ทางเลือก
คำสั่งโครงสร้าง else if (หรือ nested if) เป็นโครงสร้างที่ทำให้เราสามารถใช้คำสั่ง if else ซ้อนกันได้เรื่อย ๆ ส่วนมากจะใช้ในการตัดสินใจที่มากกว่า 2 ทางเลือกขึ้นไป บางครั้งอาจเรียกโครงสร้างนี้ว่า nested if
คำสั่ง switch เป็นคำสั่งที่ใช้ทดสอบเงื่อนไขในกรณีที่มีทางเลือกสำหรับตัดสินใจมากกว่า 2 ทางขึ้นไปเช่นเดียวกันกับ nested if โดยมากนิยมใช้คำสั่ง switch แทนคำสั่ง nested if เพราะมีรูปแบบการใช้คำสั่งที่ง่ายและสะดวกในการแก้ไขคำสั่งเมื่อมีข้อผิดพลาดเกิดขึ้น
คำสั่งที่สั่งให้ไปทำงานตามจุดที่กำหนดให้ (goto statements) ได้แก่ คำสั่ง goto และ label เป็นคำสั่งที่สั่งให้ไปทำงาน ณ จุดที่เรากำหนด โดยจะต้องตั้งเป็นชื่อ label ไว้
Page updated
Google Sites
Report abuse