1.2 โครงสร้างภายในโปรแกรม

1.2 โครงสร้างภายในโปรแกรม
            เนื้อหาในหัวข้อนี้จะกล่าวถึงรูปแบบโครงสร้างภายในโปรแกรมที่ผู้เขียน โปรแกรมจำเป็นต้องทราบ เพราะช่วยให้ผู้เขียนโปรแกรมสามารถเลือกใช้คำสั่งให้สอดคล้องกับโครงสร้าง ภายในโปรแกรมได้  ซึ่งมีเนื้อหา  2  ส่วนคือ ลักษณะของโปรแกรมแบบโครงสร้าง  และรูปแบบโครงสร้างภายในโปรแกรม  ดังรายละเอียดต่อไปนี้
            1.2.1 ลักษณะของโปรแกรมแบบโครงสร้าง
                        การเขียนโปแกรมแบบโครงสร้าง (structured  programming)  หมายถึงการเขียนโปรแกรมที่มีการนำโครงสร้างของคำสั่งหลาย ๆ รูปแบบมาใช้ในโปรแกรม  เพื่อให้โปรแกรมที่เขียนขึ้นมีขั้นตอนที่แน่นอน  และสะดวกต่อการแก้ไขโปรแกรม  โดยหลีกเลี่ยงการใช้คำสั่ง  goto  หรือใช้ให้น้อยที่สุด  เพราะคำสั่ง  goto  จะทำให้โปรแกรมมีการย้ายการทำงานจากจุดหนึ่งไปยังอีกจุดหนึ่งที่กำหนดไว้  ซึ่งอาจเกิดความสับสนในการตรวจสอบการทำงานของโปรแกรมได้
โดยทั่วไปแล้วภาษาคอมพิวเตอร์ที่เหมาะสมสำหรับการนำมาเขียนโปรแกรมแบบโครง สร้างมีหลายภาษา  ตัวอย่างเช่น  ภาษาปาสคาล (PASCAL)  ภาษาโคบอล (COBOL)  และภาษา  C  เป็นต้น  สำหรับในเอกสารนี้จะกล่าวถึงลักษณะของโปแกรมแบบโครงสร้างที่เขียนด้วยภาษา  C  เท่านั้น
            เพื่อความเข้าใจเกี่ยวกับลักษณะของโปรแกรมแบบโครงสร้างมากยิ่งขึ้น  ให้ศึกษาจากตัวอย่างโปรแกรมภาษา  C  ดังต่อไปนี้

  โปรแกรมตัวอย่างที่ 1.1 แสดงตัวอย่างโปรแกรมภาษา C ที่เป็นแบบโครงสร้างอย่างง่าย

	/*  strucpro.c  */ #include<stdio.h> void  main(void) {      /*  ส่วนที่  1  ประกาศตัวแปรและกำหนดค่าเริ่มต้นให้ตัวแปร  */             int    k= 1 ;             float  sum=0 , avg;             /*  ส่วนที่  2  คำนวณค่าผลรวมของตัวเลข  1+2+3+…+10  */             while  ( k<=10)             {                         sum+=k;                         k++;             }             /*   คำนวณค่าเฉลี่ยของตัวเลข */             avg = sum/10;             /*  ส่วนที่  3  พิมพ์ผลลัพธ์ออกทางจอภาพ */             printf(“N=%d , SUM=%.2f , AVERAGE=%.2f\n” , 10,sum,avg); }

จากตัวอย่างโปรแกรมภาษา  C  ข้างต้นจะเห็นว่าโปรแกรมนี้สามารถแบ่งส่วนของการทำงานออกเป็น  3  ส่วนที่สำคัญดังนี้
            ส่วนที่  1  คือ  ส่วนของการประกาศตัวแปรและค่าเริ่มต้นของตัวแปรที่จำเป็นต้องใช้ในโปรแกรม ซึ่งก็คือ  คำสั่ง  int  k=1;  และคำสั่ง  float = sum=0, avg;
            ส่วนที่  2  คือ ส่วนของการคำนวณค่าผลรวม  และค่าเฉลี่ยนของตัวเลข  ซึ่งก็คือ  คำสั่ง  while  และคำสั่ง  avg = sum/10;
            ส่วนที่  3  คือ ส่วนของการแสดงผลลัพธ์ทางจอภาพ ซึ่งก็คือคำสั่ง  printf( );
            สำหรับการแก้ไขโปรแกรมข้างต้นสามารถทำได้ง่ายและสะดวกมาก  ตัวอย่างเช่น  ผู้เขียนโปรแกรมต้องการแก้ไขส่วนของการแสดงผลลัพธ์ก็สามารถแก้ไขในส่วนที่  3  คือแก้ไขคำสั่ง  printf( );  เท่านั้น  ส่วนที่  1  และส่วนที่  2  ไม่ต้องแก้ไข  หรือทำนองเดียวกันถ้าต้องการแก้ไขค่าเริ่มต้นของตัวแปร  k  ให้มีค่าเป็น  10  ก็สามารถทำได้ง่ายมากโดยแก้ไขส่วนที่  1  คือคำสั่ง  int  k=1;  แก้เป็น  int k=10;
            ดังนั้นจะเห็นได้ว่าลักษณะของโปรแกรม แบบโครงสร้างจะมีการทำงานเป็นขั้นตอน ที่สามารถเข้าใจการทำงานของโปรแกรมได้ง่าย และสะดวกในการแก้ไขโปรแกรมภายหลัง

            1.2.2 รูปแบบโครงสร้างภายในโปรแกรม
                        รูปแบบโครงสร้างภายในโปรแกรมที่ควรรู้จักมีดังนี้
                        1.2.2.1 โครงสร้างแบบเรียงลำดับ

รูปที่ 1.4 แสดงโครงสร้างแบบเรียงลำดับ
ที่มา : สมชาย รัตนเลิศนุสรณ์, 2545 : 29.

                        การทำงานของโครงสร้างแบบเรียงลำดับ คือจะทำงานตามคำสั่งที่ 1, คำสั่งที่ 2, …, คำสั่งที่ n ตามลำดับ
                        1.2.2.2 โครงสร้างแบบทดสอบเงื่อนไข
โครงสร้างแบบทดสอบเงื่อนไข หมายถึง โครงสร้างของคำสั่ง ที่มีการทดสอบเงื่อนไขก่อน ที่จะทำงานอย่างใดอย่างหนึ่ง ซึ่งสามารถแบ่งออกเป็น 3 ชนิด ดังนี้
                                    1) โครงสร้างแบบทดสอบเงื่อนไข 1 ทาง

รูปที่ 1.5 แสดงโครงสร้างแบบทดสอบเงื่อนไข 1 ทาง
ที่มา : สมชาย รัตนเลิศนุสรณ์, 2545 : 29.

                                    การทำงานของโครงสร้างแบบทดสองเงื่อนไข 1 ทาง คือทำการทดสอบเงื่อนไขว่าเป็น จริงหรือเท็จ ถ้าเงื่อนไขเป็นจริง ให้ทำงานตามคำสั่งที่กำหนดไว้แล้วออกจาก การทำงาน แต่ถ้าเงื่อนไขเป็นเท็จ ให้ออกจากการทำงาน
                                    2) โครงสร้างแบบทดสอบเงื่อนไข  2  ทาง

รูปที่ 1.6 แสดงโครงสร้างแบบทดสอบเงื่อนไข 2 ทาง
ที่มา : สมชาย รัตนเลิศนุสรณ์, 2545 : 30.

                                    การทำงานของโครงสร้างแบบทดสอบเงื่อนไข 2 ทาง คือทำการทดสอบเงื่อนไขว่าเป็น จริงหรือเท็จ ถ้าเงื่อนไขเป็นจริง ให้ทำงานตามคำสั่ง A ที่กำหนดไว้แล้วออก จากการทำงาน แต่ถ้าเงื่อนไขเป็นเท็จ ให้ทำงานตามคำสั่ง B ที่กำหนดไว้ แล้วออกจากการทำงาน
3) โครงสร้างแบบทดสอบเงื่อนไขมากกว่า 2 ทางขึ้นไป

รูปที่ 1.7 แสดงโครงสร้างแบบทดสอบเงื่อนไขมากกว่า 2 ทางขึ้นไป
ที่มา : สมชาย รัตนเลิศนุสรณ์, 2545 : 30.

การทำงานของโครงสร้างแบบทดสอบเงื่อนไขมากกว่า 2 ทางขึ้นไป
มีลักษณะดังต่อไปนี้
1. ทำการทดสอบเงื่อนไขที่ 1 ว่าเป็นจริงหรือเท็จ ถ้าเงื่อนไขเป็นจริง ให้ทำงาน ตามคำสั่ง A ที่กำหนดไว้แล้วออกจากการทำงาน แต่ถ้าเงื่อนไขเป็นเท็จ ให้ทำ งานในข้อ 2.
2. ทำการทดสอบเงื่อนไขที่ 2 ว่าเป็นจริงหรือเท็จ ถ้าเงื่อนไขเป็นจริง ให้ทำงาน ตามคำสั่ง B ที่กำหนดไว้แล้วออกจากการทำงาน แต่ถ้าเงื่อนไขเป็นเท็จ ให้ทำ งานในข้อ 3.
3. ทำการทดสอบเงื่อนไขใหม่อีก โดยทำซ้ำเช่นนี้ไปเรื่อย ๆ จนกว่าจะถึงเงื่อนไขสุดท้าย (เงื่อนไขที่ n) ถ้าเงื่อนไขเป็นจริง ให้ทำงาน ตามคำสั่ง N ที่กำหนดไว้แล้วออกจากการทำงาน แต่ถ้าเงื่อนไขเป็นเท็จ ให้ออก จากการทำงาน
                        1.2.2.3 โครงสร้างแบบทำงานวนลูป
                                    โครงสร้างแบบทำงานวนลูป หมายถึง โครงสร้างของคำสั่งที่มีการทำงานซ้ำ ๆ เป็นวงจรปิด จนกว่าเงื่อนไขที่ทดสอบจะตรงกับค่าจริงหรือเท็จตามโครงสร้างที่ ใช้ จึงสามารถออกจากการทำงานได้ ซึ่งสามารถแบ่งออกเป็น 2 ชนิด ดังนี้
                                    1) โครงสร้างแบบ DO UNTIL

รูปที่ 1.8 แสดงโครงสร้างแบบ DO UNTIL
ที่มา : สมชาย รัตนเลิศนุสรณ์, 2545 : 31.

                                    การทำงานของโครงสร้างแบบ DO UNTIL คือเริ่มต้นด้วยการทำงานตามคำสั่งที่ต้อง การภายในลูปจนหมดคำสั่งไป 1 รอบ จากนั้นจึงทำการทดสอบเงื่อนไขว่าเป็นจริง หรือเท็จ ถ้าเงื่อนไขเป็นเท็จ ให้กลับไปทำงานตามคำสั่งภายในลูปอีก ทำงานซ้ำ ๆ เช่นนี้จนกว่าเงื่อนไขเป็นจริง จึงออกจากการทำงานแบบนี้ได้ ลักษณะของโครง สร้างแบบ DO UNTIL นี้จะตรงกับคำสั่ง REPEAT UNTIL ในภาษาปาสคาล
                                    2) โครงสร้างแบบ DO WHILE

รูปที่ 1.9 แสดงโครงสร้างแบบ DO WHILE
ที่มา : สมชาย รัตนเลิศนุสรณ์, 2545 : 32.
                                    การทำงานของโครงสร้างแบบ DO WHILE คือเริ่มต้นด้วยการทดสอบเงื่อนไขว่าเป็น จริงหรือเท็จ ถ้าเงื่อนเป็นจริง ให้ทำงานตามคำสั่งที่ต้องการภายในลูปจนหมด คำสั่ง จากนั้นจึงย้อนกลับไปทำการทดสอบเงื่อนไขอีกครั้งว่าเป็นจริงหรือ เท็จ ถ้าเงื่อนไขเป็นจริง ให้ทำงานตามคำสั่งภายในลูปอีก ทำงานซ้ำ ๆ เช่นนี้จนกว่าเงื่อนไขเป็นเท็จ จึงออกจากการทำงานแบบนี้ได้ ลักษณะของโครง สร้าง DO WHILE นี้จำตรงกับคำสั่ง while ในภาษา C

ข้อควรระวังของโครงสร้างแบบทำงานวนลูป คือ การทำสอบเงื่อนไขจะต้องมีทั้ง 2 กรณี คือเป็นจริง และเป็นเท็จ ตัวอย่าง เช่น โครงสร้างแบบ DO UNTIL ถ้าเงื่อนไขที่ทดสอบไม่มีกรณีที่เป็นจริง จะทำ ให้การทำงานของโปรแกรมทำงานซ้ำ ๆ แบบไม่มีทางออกได้ ในทำนองเดียวกันโครงสร้างแบบ DO WHILE ถ้าเงื่อนไขที่ ทดสอบไม่มีกรณีที่เป็นเท็จ จะทำให้การทำงานของโปรแกรมวนทำงานซ้ำ ๆ แบบไม่มีทางออกได้