รายงาน
เรื่อง การเขียนโปรแกรมด้วยภาษาซี
จัดทำโดย
นาย สุพัฒน์พงษ์ ศรีมะโรง
เสนอ
คุณครู สมร มาลา
โรงเรียนกุดบงพิทยาคาร
ความรู้เบื้องต้นเกี่ยวกับภาษาซี
การพัฒนาโปรแกรมคอมพิวเตอร์ บางคนก็ว่ายาก บางคนก็ว่าเป็นเรื่องสนุก หลายคนบอกว่า ขอเป็นแค่ผู้ใช้สนุกที่สุด แต่จะมีซักกี่คนที่จะมีใจรักที่จะก้าวไปบนถนนแห่งการพัฒนาฝีมือและฝึกฝนการเขียนโปรแกรมด้วยตัวเอง เพื่อให้มีผู้ที่สนใจนำไปใช้งาน และเพิ่มประสิทธิ์ภาพในการทำงาน และ ความสะดวกสบายๆ ต่างๆมากขึ้น ว่าไปแล้วนักโปรแกรมเมอร์เหล่านี้ ก็ไม่แตกต่างจากผู้ที่ปิดทองหลังพระมากนัก เพราะหลายๆ โปรแกรมที่มีให้ใช้งานกันในปัจจุบัน จะมีใครทราบบ้างไหมว่า ผู้เขียนโปรแกรมเหล่านั้นมีใครกันบ้าง ดังนั้น ผู้ที่คิดจะก้าวมาเป็นนักพัฒนาโปรแกรมมืออาชีพ คงต้องอาศัยใจรักที่จะอยากจะพัฒนา และฝึกฝนฝืมือในการเป็นโปรแกมเมอร์มืออาชีพมาเป็นอันดับหนึ่ง สำหรับบทความนี้จะเริ่มต้นด้วยการสอนให้เข้าใจในหลักการพื้นฐานของการการพัฒนาโปรแกรมในภาษา C ความรู้และความเข้าใจที่จำเป็นต่อการเป็นโปรแกรมเมอร์มืออาชีพในอนาคต เราลองเริ่มมาเรียนรู้กันอย่างคร่าวๆ กันเลยล่ะกัน โดยผู้เขียนจะอธิบายเป็นตอนๆ ทั้งหมด 8 ตอนด้วยกันได้แก่
1. พื้นฐานโปรแกรมภาษา C (Introduction to C Programming)
2. การเขียนโปรแกรมทางเลือก (Selection Structures)
3. การเขียนโปรแกรมแบบ วนซ้ำ (Repetition & Loop)
4. ฟังก์ชัน และการเขียนโปรแกรมแยกเป็นโมดูล (Functions & Modular Programming)
5. ตารางอาเรย์ (Arrays)
6. ตัวแปรพอยเตอร์ (Pointers)
7. ตัวแปรสตริง (String)
8. โครงสร้างสตักเจอร์ (Structure)
1. พื้นฐานโปรแกรมภาษา C (Introduction to C Programming)
ก่อนอื่นของแนะนำพื้นฐานเกี่ยวกับคอมพิวเตอร์กันซักนิด ก่อนที่จะเริ่มเรียนรู้ภาษา C กัน หน่วยสำคัญที่สุดของคอมพิวเตอร์ก็คือ หน่วยประมวลผลหรือที่เรียกกันว่า CPU โดยปกติ CPU จะมีภาษาของตัวเองที่เรียกว่า ภาษาเครื่อง (Machine Language) ซึ่งจะเป็นภาษาที่ประกอบไปด้วยเลขฐานสองมากมาย ดังนั้นการที่จะเขียนโปรแกรมควบคุมการทำงานของคอมพิวเตอร์ โดยใช้ภาษาเครื่องโดยตรงนั้นจึงทำได้ยาก จึงได้มีการพัฒนาตัวแปรภาษาเครื่องที่เรียกว่า โปรแกรมภาษาระดับสูงขึ้นมา หรือที่เรียกว่า High Level Languages โดยภาษาในระดับสูงเหล่านี้ จะมีลักษณะรูปแบบการเขียน (Syntax) ที่ทำให้เข้าใจได้ง่ายต่อการสื่อสารกับผู้พัฒนา และถูกออกแบบมาให้ง่ายต่อการใช้งาน และจะเปลี่ยนคำสั่งจากผู้ใช้งาน ไปเป็นเป็นภาษาเครื่อง เพื่อที่จะควบคุมการทำงานของคอมพิวเตอร์ต่อไป ตัวอย่างของโปรแกรมภาษาระดับสูง ได้แก่ COBOL ใช้กันมากสำหรับโปรแกรมทางด้านธุรกิจ, Fortran ใช้กันมากสำหรับการพัฒนาโปรแกรมด้านวิทยาศาสตร์และวิศวกรรมศาสตร์ เพราะง่ายต่อการคำนวณ, Pascal มีใช้กันทั่วไป แต่เน้นสำหรับการพัฒนาเครื่องมือสำหรับการเรียนการสอน, C & C++ ใช้ทั่วไป ปัจจุบันมีผู้เลือกที่จะใช้กันอย่างแพร่หลาย, PROLOG เน้นหนักไปทางด้านงานประเภท AI และ JAVA ใช้ได้ทั่วไป ปัจจุบันเริ่มมีผู้หันมาสนใจกันมากและเพิ่มขึ้นอย่างรวดเร็ว
คราวนี้เราลองมาเตรียมตัวกันซักนิก ก่อนที่จะลงมือพัฒนาโปรแกรมคอมพิวเตอร์ ขั้นแรก เราต้องศึกษารูปแบบความต้องการของโปรแกรมที่จะพัฒนา จากนั้นก็วิเคราะห์ถึงปัญหาตลอดจนวิธีการแก้ปัญหา จากนั้นจึงนำเอาความคิดในการแก้ปัญหาอย่างเป็นขั้นตอน ไปเขียนในรูปแบบของโปรแกรมภาษาในระดับสูง ซึ่งจะอยู่ในรูปแบบของ Source Program หรือ Source Code จากนั้นเราก็จะใช้ Complier ของภาษาที่เราเลือก มาทำการ Compile Source code หรือกล่าวง่ายๆ คือแปลง Source code ของเราให้เป็นภาษาเครื่องนั่นเอง ซึ่งในขั้นตอนนี้ ผลที่ได้ เราจะเรียกว่า Object code จากนั้น Complier ก็จะทำการ Link หรือเชื่อม Object code เข้ากับฟังก์ชันการทำงานใน Libraries ต่างๆ ที่จำเป็นต่อการใช้งาน แล้วนำไปไว้ในหน่วยความจำ แล้วเราก็จะสามารถ Run เพื่อดูผลของการทำงานโปรแกรมได้ หากโปรแกรมมีข้อผิดพลาด เราก็จะทำการแก้ หรือที่เรียกกันในภาษาคอมพิวเตอร์ว่า การ Debug นั่นเอง
ภาษา C เป็นโปรแกรมภาษาระดับสูง ถูกพัฒนาขึ้นในปี 1972 ที่ AT&T Bell Lab เราสามารถใช้ภาษา C มาเขียนเป็นคำสั่งต่างๆ ที่คอมพิวเตอร์สามารถเข้าใจได้ และกลุ่มของคำสั่งเหล่านี้ เราก็เรียกกันว่า อัลกอริธึม ได้มีผู้ให้คำจำกัดความของคำว่า อัลกอริธึม ว่าเป็น “A precise description of a step-by-step process that is guaranteed to terminate after a finite number of steps with a correct answer for every particular instance of an algorithmic problem that may occur.” สำหรับ Compiler ภาษา C ที่มีในปัจจุบัน มี 2 ค่ายใหญ่ๆ ที่มีผู้คนสนใจใช้กันมากได้แก่ Microsoft และ Borland การใช้งาน Compiler ทั้งสองตัวนี้ สามารถเรียนรู้ได้ไม่ยากนัก เราจึงจะมาเริ่มต้นที่การเขียนโปรแกรมในภาษา C กันเลย เราลองมาเริ่มจากตัวอย่างการเขียน ภาษา C แบบ ง่ายๆ กันก่อนกับโปรแกรม Hello World
ตัวแปร (Variables)
ตัวแปรจะเป็นชื่อที่ใช้ในการบอกจำนวนหรือปริมาณ ซึ่งสามารถที่จะทำการเปลี่ยนแปลงจำนวนได้ด้วยโปรแกรมคอมพิวเตอร์ การตั้งชื่อตัวแปร จะต้องตั้งชื่อให้แตกต่างไปจากชื่อของตัวแปรอื่นๆ ยกตัวอย่างชื่อของตัวแปร ได้แก่ x, y, peter, num_of_points และ streetnum เป็นต้น โดยปกติการเขียนโปรแกรมที่ดี ควรจะตั้งชื่อตัวแปรให้สอดคล้องกับการทำงานหรือหน้าที่ของตัวแปรนั้นๆ เพราะเมื่อถึงเวลาต้องมาทำการปรับปรุงแก้ไขโปรแกรม จะสามารถทำได้โดยไม่ยากนัก
ในภาษา C หรือ C++ ได้มีกฏในการตั้งชื่อตัวแปรที่สามารถใช้งานได้ดังนี้
– ชื่อตัวแปรจะต้องขึ้นต้นด้วยตัวอักษร
– ชื่อตัวแปรจะประกอบไปด้วย ตัวอักษร ตัวแลข และ _ ได้เท่านั้น
– ชื่อตัวแปรจะต้องไม่ใช่ชื่อ reserved word (ชื่อที่มีการจองไว้แล้ว)
ตัวอย่างของชื่อตัวแปรที่สามารถนำมาใช้ตั้งชื่อได้ ได้แก่
length, days_in_year, DataSet1, Profit95, Pressure, first_one
และตัวอย่างของชื่อ ที่ไม่สามารถนำมาใช้เป็นชื่อตัวแปรได้ ยกตัวอย่างเช่น
day-in-year, 1data, int, first.val เป็นต้น
reserved word (ชื่อที่มีการจองไว้แล้ว)
Reserved words หรือตัวแปรที่ได้จองไว้แล้วนั้น จะประกอบไปด้วยตัวอักษรตัวเล็กทั้งหมด และจะมีความสำคัญสำหรับภาษา C++ และจะไม่นำมาใช้ด้วยวัตถุประสงค์อื่นๆ ตัวอย่างของ Reserved words ได้แก่ and, bool, break, case, catch, char, class, continue, default, delete, do, double, if , else, enum, export, extern เป็นต้น
นอกจากนี้ในภาษา C หรือ C++ ชื่อตัวแปร ที่ประกอบไปด้วยอักษรเล็ก หรือใหญ่ ก็มีความแตกต่างกัน หรือที่เรียกว่า Case sensitive ยกตัวอย่างเช่น
‘X’ และ ‘x’ เป็นตัวแปรต่างกัน
‘peter’ และ ‘Peter’ เป็นตัวแปรต่างกัน
‘bookno1’ และ ‘bookNo1’ เป็นตัวแปรต่างกัน
‘XTREME’ และ ‘xtreme’ เป็นตัวแปรต่างกัน
‘X1’ และ ‘x1’ เป็นตัวแปรต่างกัน
‘int’ และ ‘Int’ เป็นตัวแปรต่างกัน
การกำหนดชนิดของตัวแปร (Declaration of Variables)
ในภาษา C หรือ C++ (และโปรแกรมในภาษาอื่นๆ) ตัวแปรทุกตัวที่จะมีการเรียกใช้ในโปรแกรมจำเป็นต้องมีการกำหนดชนิดของตัวแปรนั้นๆ ก่อนที่จะทำการเรียกใช้ตัวแปร
การกำหนดชนิดของตัวแปรมีวัตถุประสงค์หลัก 2 ประการได้แก่
– เป็นการบอกชนิด และตั้งชื่อตัวแปรที่จะเรียกใช้ ชนิดของตัวแปรจะทำให้คอมไพเลอร์สามารถแปลคำสั่งได้อย่างถูกต้อง (ยกตัวอย่างเช่น ใน CPU คำสั่งที่ใช้ในการบวกตัวเลขจำนวนเต็ม 2 จำนวน ย่อมแตกต่างจากคำสั่งที่จะบวกจำนวนจริง 2 จำนวนเข้าด้วยกัน)
– ชนิดของตัวแปร ยังเป็นบ่งบอกคอมไพเลอร์ให้ทราบว่าจะต้องจัดเตรียมเนื้อที่ให้กับตัวแปรตัวนั้นมากน้อยเท่าใด และจะจัดวางตัวแปรนั้นไว้แอดเดรส (Address) ไหนที่สามารถเรียกมาใช้ใน code ได้
สำหรับในบทความนี้จะพิจารณาชนิดตัวแปร 4 ชนิดที่ใช้กันมากได้แก่ int, float, bool และ char
int ชนิดตัวแปรที่สามารถแทนค่าจำนวนเต็มได้ทั้งบวกและลบ โดยปกติสำหรับคอมพิวเตอร์ทั่วไป คอมไพเลอร์ จะจองเนื้อที่ 2 ไบต์ สำหรับตัวแปรชนิด int จึงทำให้ค่าของตัวแปรมีค่าตั้งแต่ -32768 ถึง +32768
ตัวอย่างของค่า int ได้แก่ 123 -56 0 5645 เป็นต้น
floatชนิดของตัวแปรที่เป็นตัวแทนของจำนวนจริง หรือตัวเลขที่มีค่าทศนิยม ความละเอียดของตัวเลขหลังจุดทศนิยมขึ้นอยู่กับระบบคอมพิวเตอร์ โดยปกติแล้ว ตัวแปรชนิด float จะใช้เนื้อที่ 4 ไบต์ นั่นคือจะให้ความละเอียดของตัวเลขหลังจุดทศนิยม 6 ตำแหน่ง และมีค่าอยู่ระหว่าง -1038 ถึง +1038
ตัวอย่างของค่า float ได้แก่ 16.315 -0.67 31.567
bool ชนิดของตัวแปรที่สามารถเก็บค่าลอจิก จริง (True) หรือ เท็จ (False) ตัวแปรชนิดนี้ เป็นที่รู้จักกันอีกชื่อคือ ตัวแปรบูลีน (Boolean)
ตัวอย่างของตัวแปรชนิด bool ได้แก่ 1 0 true false (เมื่อ 1 = true และ 0 = false)
char เป็นชนิดตัวแปรที่เป็นตัวแทนของ ตัวอักษรเพียงตัวเดียว อาจเป็นตัวอักษร ตัวเลข หรือตัวอักขระพิเศษ โดยปกติตัวแปรชนิดนี้จะใช้เนื้อที่เพียง 1 ไบต์ ซึ่งจะให้ตัวอักษรในรูปแบบที่แตกต่างกันได้ถึง 256 ค่า การเขียนรูปแบบของ char หลายๆ ตัว โดยปกติ จะอ้างอิงกับ American Standard Code for Information Interchange (ASCII)
ตัวอย่างของตัวแปรชนิด char ได้แก่ ‘+’ ‘A’ ‘a’ ‘*’ ‘7’
การกำหนดชนิดของตัวแปร สามารถเขียนได้อยู่ในรูป type identifier-list;
เมื่อ type บ่งบอกชนิดของตัวแปร ส่วน identifier-list เป็นการกำหนดชื่อของตัวแปร ซึ่งอาจจะมีมากกว่า 1 ตัวแปร และจะแยกตัวแปรแต่ละตัวออกจากกันด้วยเครื่องหมาย comma (,)
ตัวอย่าง รูปแบบของการกำหนดชนิดของตัวแปร ได้แก่ int i, j, count;
การให้กำหนดค่าตัวแปร (Variable Assignment)
เราสามารถกำหนดค่าให้กับตัวแปรได้ ด้วยเครื่องหมาย = ยกตัวอย่างเช่น
int name; // กำหนดตัวแปร name ที่เก็บค่าจำนวนเต็ม
name = 23; // กำหนดให้ตัวแปร name มีค่าเป็น 23
ในขณะเดียวกัน เราสามารถใช้เครื่องหมาย = ระหว่างตัวแปรกับตัวแปร หรือตัวแปรกับจำนวนใดๆ ได้ อาทิเช่น
change = x1 - x2;
mean = (x1 + x2)/2;
x = x + 1;
ตอนนี้เราลองมาเขียนโปรแกรมอย่างง่าย เพื่อทำการแก้ปัญหาทางคณิตศาสตร์ ด้วยการแปลงค่า อุณหภูมิ ในหน่วยของ ฟาเรนไฮต์ เป็น เซลเซียส เมื่ออุณหภูมิในหน่วยฟาเรนไฮต์ มีค่า = 85 และเป็นที่ทราบกันดีว่า ความสัมพันธ์ระหว่าง องศาฟาเรนไฮต์ และ เซลเซียส สามารถเขียนได้อยู่ในรูปของสมการ
การเขียนโปรแกรม เพื่อแก้ปัญหา การแปลงค่า 85 ฟาเรนไฮต์ให้เป็นเซลเซียส สามารถเขียนได้ดังนี้
#include <STDIO.H>
void main()
float F;
float C;
F = 85;
C = 5*(F-32)/9;
printf("the result is %f",C);
อีกตัวอย่าง ของโปรแกรม การบวกค่าจำนวนเต็ม 2 จำนวนเข้าด้วยกัน แล้วแสดงผลลัพธ์ออกทางหน้าจากการเขียนโปรแกรมเพื่อแก้ปัญหานี้ สามารถเขียนได้ดังนี้
#include <STDIO.H>
void main()
{
int N1, N2, Sum;
printf("please input an integer number : ");
scanf("%d",&N1);
printf("please input another integer number : ");
scanf("%d",&N2);
Sum = N1 + N2;
printf("so, %d + %d = %d",N1,N2,Sum);
จากตัวอย่างการเขียนโปรแกรมข้างต้น จะเห็นว่ามีการคำนวณทางคณิตศาสตร์เข้ามาเกี่ยวข้อง คราวนี้เราลองมาดู การคำนวณในภาษา C กันว่าจะเขียนกันได้อย่างไรบ้าง
การเปรียบเทียบ แบบมีทางเลือก (Selection Structures)
.การเขียนโปรแกรมแบบมีทางเลือก (Selection Structures)
การเขียนโปรแกรมแบบมีทางเลือก จะสามารถทำให้โปรแกรมสามารถตัดสินใจหรือเปรียบเทียบ จากนั้นก็จะเลือกดำเนินการไปในทิศทางหนึ่งจากสองทิศทาง ขึ้นอยู่กับผลที่ได้จากการเปรียบเทียบนั้น
เงื่อนไข (Condition)
– เป็นตัวกำหนดเงื่อนไขที่ผู้พัฒนาโปรแกรมได้สร้างขึ้นมา
– ผลลัพธ์ที่ได้จากเงื่อนไข จะมีค่า จริงหรือ เท็จ
โครงสร้างของเงื่อนไข (Condition Control Structures)
ประโยคเงื่อนไขสามารถที่จะเขียนให้อยู่ในรูปภาษา C จะเขียนได้ดังนี้
if condition then A else B
ซึ่งหมายความว่า ถ้าเงื่อนไข (condition) มีค่าเป็นจริง ก็จะดำเนินการทำคำสั่ง A มิเช่นนั้นก็จะทำคำสั่ง B
ตัวอย่างของการเขียนโครงสร้างทางเลือกในภาษา C สามารถเขียนได้ดังนี้
if (x < y)
a = x * 2;
else
a = x + y;
ความหมายของ code ดังกล่าว หมายความว่า ถ้า ค่า x มีค่าน้อยกว่า y แล้ว a = x*2
แต่ถ้า x มีค่ามากกว่าหรือเท่ากับ y แล้ว a = x+y นั่นเอง
รูปแบบของเงื่อนไข ส่วนใหญ่จะอยู่ในรูป “ตัวแปร โอเปอเรเตอร์ ตัวแปร” โอเปอเรเตอร์ที่กล่าวถึงนี้จะมีอยู่ 2 แบบ ด้วยกันคือ โอเปอเรเตอร์สัมพันธ์ (Relational Operator) และ โอเปอเรเตอร์ลอจิก (Logical Operator)
โอเปอเรเตอร์สัมพันธ์ที่ใช้ในภาษา C มีดังต่อไปนี้
if ( condition1 )
statement1 ;
else
if ( condition2 )
statement2 ;
. . .
else if ( condition-n )
statement-n ;
else
statement-e ;
ยกตัวอย่างของโปรแกรม Nested if สามารถเขียนได้ดังนี้
if (x < 0.25)
count1++;
else if (x < 0.5)
count2++;
else if (x < 0.75)
count3++;
else
count4++;
นอกจากรูปแบบของ if-else แล้ว เรายังสามารถใช้เครื่องหมาย ? มาประยุกต์ในการเขียน code เพื่อให้ได้ความหมายเดียวกันกับ if-else ดังแสดงให้เห็นดังนี้
if (x < y)
a = x * 2;
else
a = x + y;
สามารถเขียนได้ในอีกรูปแบบหนึ่งคือ a = x < y ? x*2: x+y ; // ซึ่งจะให้ความหมายเดียวกันกับ code ข้างบนนั่นเอง
ในบางครั้งที่เราต้องเขียนโปรแกรมแบบมีทางเลือก โดยบางครั้งเราต้องการให้มีทางเลือกมากว่า 2 ทาง Nested if เป็นวิธีหนึ่งที่สามารถใช้แก้ปัญหาได้ แต่เพื่อให้ง่ายขึ้น ในภาษา C เราจึงสามารถใช้คำสั่ง switch ได้ โดยรูปแบบการเขียน คำสั่ง switch สามารถเขียนให้อยู่ในรูป
switch (selector)
{
case label1: statement1;
break;
case label2: statement2;
break;
...
case labeln: statementn;
break;
default: statementd; // optional
break;
}
โดยที่ selector จะต้องเป็นจำนวนเต็ม ตัวอักษร หรือผลลัพธ์ของการกระทำที่ให้เลขจำนวนเต็มหรือตัวอักษร ตัวอย่างของการเขียน code โดยมีการเรียกใช้คำสั่ง switch สามารถเขียนได้ดังนี้
switch (i)
{
case 1 : grade = ‘A’;
break;
case 2 : grade = ‘B’;
break;
case 3 : grade = ‘c’;
break;
default : printf(“%c not in range”, i);
break;
}
โดยหลักการของ switch คือ compiler จะทำการเปรียบเทียบค่าของ selector เทียบกับ label ถ้าไม่ตรงกับ label ใดๆ ก็จะเข้าไปทำในคำสั่งของ default นอกจากนี้ การใส่คำสั่ง break หรือไม่มีคำสั่ง break ก็จะให้ผลลัพธ์ที่แตกต่างกัน ดังแสดงให้เห็นดังตัวอย่างต่อไปนี้ (ทดลอง Run แล้วจะเห็นความแตกต่าง)
การเปรียบเทียบตัวอักษร
คุณผู้อ่านทราบกันหรือไม่ว่า ตัวอักษรสามารถเปรียบเทียบค่ากันได้ เบื้องต้นเราต้องทราบก่อนว่า ตัวอักษรมีค่าอย่างไรกันบ้าง
ตัวอักษรตัวเล็ก ‘a’ มีค่า 97 ไปจนถึง ‘z’ มีค่า 122
ตัวอักษรตัวใหญ่ ‘A’ มีค่า 65 ไปจนถึง ‘Z’ มีค่า 90
ตัวอย่างของการเปรียบเทียบตัวอักษร สามารถแสดงให้เห็นได้ดังนี้
‘9’ >= ‘0’ มีค่าเป็นจริง (1)
‘a’ < ‘e’ มีค่าเป็นจริง (1)
‘B’ <= ‘A’ มีค่าเป็นเท็จ (0)
‘a’ <= ‘A’ ขึ้นอยู่กับระบบ แต่ส่วนใหญ่ เป็นเท็จ
‘a’ <= ‘c’ && ‘c’ <= ‘z’ มีค่าเป็นจริง
คราวนี้เราลองมาดูโจทย์กัน สมมุติว่า เราจะเขียนโปรแกรม เพื่ออ่านค่าตัวอักษร 4 ตัว แล้ว เราต้องการที่จะเปลี่ยนตัวอักษรแต่ละตัว ให้เป็นตัวอักษรใหญ่ หรือเล็กที่ตรงข้ามกับค่าที่รับเข้าไป ยกตัวอย่างเช่น PooH ให้เปลี่ยนเป็น pOOh เราจะเขียนโปรแกรมอย่างไร
คำตอบ วิธีหนึ่งที่สามารถทำได้ คือใช้ Nested-if ดังนี้
#include <STDIO.H>
void main()
{
char A, B, C, D;
printf(“Input 4 charactersn”);
scanf(“%c %c %c %c”, &A, &B, &C, &D);
if((A <= 90)&&(A >= 65)) A = (A – 65) + 97;
else if ((A >= 97)&&(A <= 122)) A = (A-97) + 65;
else A = A;
if((B <= 90)&&(B >= 65)) B = (B – 65) + 97;
else if ((B >= 97)&&(B <= 122)) B = (B-97) + 65;
else B = B;
if((C <= 90)&&(C >= 65)) C = (C – 65) + 97;
else if ((C >= 97)&&(C <= 122)) C = (C-97) + 65;
else C = C;
if((D <= 90)&&(D >= 65)) D = (D – 65) + 97;
else if ((D >= 97)&&(D <= 122)) D = (D-97) + 65;
else D = D;
printf(“The answer is %c %c %c %cn”, A, B, C, D);
3.การเขียนโปรแกรมแบบ วนซ้ำ (Repetition & Loop)
กระบวนการหนึ่งที่สำคัญในการออกแบบอัลกอริทึม ก็คือความสามารถในการวนลูปของการทำงานของกลุ่มคำสั่งตามที่นักพัฒนาต้องการ ดังนั้นสำหรับตอนนี้ ก็จะนำเสนอการพัฒนาโปรแกรมเพื่อให้บางส่วนของคำสั่งสามารถมีการวนซ้ำได้หลายครั้ง สำหรับคำสั่งที่สามารถใช้ในการเขียนโปรแกรมแบบวนซ้ำในภาษา C ได้แก่ While, Do-while และ For
ตัวอย่างของการใช้คำสั่ง while, for และ do-while สามารถเขียนให้เห็นได้ดังตาราง
ซึ่งผลลัพทธ์ของโปรแกรมทั้ง 3 ข้างต้นจะให้ผลลัพท์ที่เหมือนกัน คือจะแสดงผลบนหน้าจอเป็น
i = 0
i = 1
i = 2
i = 3
i = 4
i = 5
i = 6
คราวนี้เราลองมาดูโครงสร้างของการใช้งานแต่ละคำสั่งกัน
while ( condition ) // เมื่อ เงื่อนไข (condition) เป็นจริง ก็จะทำการวนซ้ำ ใน statement ถัดไป
statement
ยกตัวอย่างเช่น
sum = 0.0;
x = 5;
while (x > 0.0)
{
sum += x;
x = x – 1;
}
ในที่นี้จะเห็นว่า ค่า x มีค่าเริ่มต้นเท่ากับ 5 ซึ่ง 5 > 0 เงื่อนไขของคำสั่ง while เป็นจริง จึงทำคำสั่งถัดมาคือ sum += x; หมายความว่า sum = sum + x = 5 จากนั้นค่า x ก็มีค่าลดลงไป 1 เหลือ 4 ก็จะทำการ check เงื่อนไขว่า 4 > 0 หรือไม่ เมื่อเงื่อนไขเป็นจริง ก็จะทำการวนซ้ำ sum ก็จะมีค่าเป็น 5 + 4 = 9 และ x ก็จะมีค่าลดลงเหลือ 3 และดำเนินการวนซ้ำเช่นนี้จนกระทั่ง x มีค่าเป็น 0 ซึ่งค่า 0 ไม่ได้มีค่ามากกว่า 0.0 เงื่อนไขจึงเป็นเท็จ โปรแกรมจึงจะจบการวนซ้ำ
คราวนี้เราลองมาดูตัวอย่างของการใช้คำสั่ง while ในการเขียนโปรแกรมแบบวนซ้ำ และผลลัพท์ที่ได้
x=0;
while( x <=2 ){
printf("%d %dn",x, x*2);
}
ผลลัพท์ที่ได้จะได้ดังนี้
0 0
0 0
0 0
: :
0 0 (infinite loop)
การที่ผลลัพท์ออกมาเช่นนี้ ก็เนื่องจากว่า x มีค่าเริ่มต้น 0 และเงื่อนไข x <= 2 เป็นจริงตลอด โปรแกรมจึงทำการพิมพ์ค่า 0 0 ออกมา และเนื่องจากค่า x ไม่มีการเปลี่ยนแปลง เงื่อนไขจึงเป็นจริงตลอด โปรแกรมจึงแสดงผลบนหน้าจอโดยไม่หยุดนั่นเอง อีกตัวอย่างของการใช้งาน while ในการเขียนโปรแกรมแบบวนซ้ำ แสดงได้ดังนี้
scanf(“%d”,&n);
a = 10;
while (a > n) {
printf(“%dn”,a);
a = a-1;
}
ผลลัพท์ของโปรแกรมจะสามารถแสดงให้เห็นได้ดังนี้
10
9
8
7
คราวนี้เราลองมาแก้โจทย์ปัญหา การหาค่า ห.ร.ม (หารร่วมมาก) ของตัวเลข 2 ตัวใดๆ โดยอัลกอริทึม Euclidean โดยอัลกอริทึมดังกล่าว จะทำการแปลงค่าตัวเลข 2 ตัวเลขบวกใดๆ (m, n) เป็นค่า (d, 0) โดยการนำตัวเลขที่มีค่ามาก นำมาหารด้วยตัวเลขที่มีค่าน้อยกว่า นำค่าเศษที่หารได้มาแทนตัวเลขที่มีค่ามากกว่า ทำเช่นนี้จนกระทั่งได้ค่าเศษจากการหารมีค่าเป็น 0 ตัวเลขอีกตัวก็จะเป็นค่า ห.ร.ม. ยกตัวอย่างเมื่อเราทำการ Run โปรแกรม จะได้ผลดังนี้
Enter two positive integers: 532 112
The g.c.d. of 532 and 112 is 28
คราวนี้เราลองมาดูการเขียนโปรแกรมเพื่อแก้ปัญหาดังกล่าวข้างต้น สามารถเขียนได้ดังนี้
#include <STDIO.H>
void main()
{
int A, B, start;
printf("Enter two positive intergers: ");
scanf("%d %d", &A, &B);
if(A < B) start = A;
else start = B;
while(((A%start) != 0)||((B%start) != 0))
{
start = start-1;
}
printf("The g.c.d of %d and %d is %dn", A, B, start);
}
การดำเนินการทางคณิตศาสตร์ สามารถเขียนให้อยู่ในรูปแบบสั้นๆ ได้ ดังตัวอย่างในตารางดังนี้
ความแตกต่างระหว่าง i++ และ ++i
i++ และ ++i จะมีความหมายใกล้เคียงกันมาก จะแตกต่างเพียง การจัดลำดับในการคำนวณ เมื่อต้องนำไปใช้กับตัวแปรตัวอื่น
A = 10;
C = A++; // A= 11, C = 10
A = 10;
C = ++A; // A = 11, C = 11
A = 10;
C = A–; // A = 9, C = 10
A = 10;
C = –A; // A = 9, C = 9
โครงสร้างการเขียนโปรแกรมแบบวนซ้ำโดยใช้คำสั่ง For
คำสัง for สามารถเขียนให้อยู่ในรูปแบบได้ดังนี้
for ( เริ่มต้น ; เงื่อนไข ; เปลี่ยนแปลง )
statement;
เมื่อเริ่มต้น เป็นการกำหนดค่าตัวแปรเริ่มต้นที่ต้องการ ส่วนเงื่อนไขหากค่าลอจิกมีค่าเป็นจริง ก็จะทำตามในโครงสร้างของการวนซ้ำคือ run คำสั่ง statement แต่ถ้าเป็นเท็จก็จะออกจากโครงสร้างการวนซ้ำ ส่วนเปลี่ยนแปลง จะทำการปรับค่าของตัวแปรที่ต้องการ ยกตัวอย่างเช่น
for ( count=0 ; count < 10 ; count++)
{
printf(“count = %dn”,count);
}
ใน code ข้างต้น ตัวแปร count จะเริ่มต้นจากค่า 0 ซึ่งค่า 0 มีค่าน้อยกว่า 10 ก็จะทำคำสั่ง print ค่าของตัวแปร count จากนั้นค่า count ก็จะเพิ่มค่าเป็น 1 เงื่อนไข count < 10 ก็ยังคงเป็นจริง ก็จะทำการพิมพ์ ค่าของตัวแปร count วนซ้ำเช่นนี้ จนกระทั่ง count มีค่าเพิ่มขึ้นจนเป็น 10 เงื่อนไขก็จะเป็นเท็จ และจบโครงสร้างของการวนซ้ำ
การเปลี่ยนแปลงค่าของตัวแปร อาจจะมีการเปลี่ยนแปลงมากกว่า 1 ค่า ยกตัวอย่างเช่น
for ( count=0 ; count < 10 ; count += 2) // ตัวแปร count มีค่าเปลี่ยนแปลงเพิ่มขึ้นครั้งละ 2
{
printf(“count = %dn”,count);
}
for ( count=10 ; count > 5 ; count -= 2) // ตัวแปร count มีค่าเปลี่ยนแปลงลดลงครั้งละ 2
{
printf(“count = %dn”,count);
}
นอกจากนี้เรายังสามารถใช้ตัวแปร เป็นการกำหนด ค่าเริ่มต้น เงื่อนไข และ เปลี่ยนแปลงได้ ยกตัวอย่างเช่น
start = 0; end = 20; step=3;
for ( count=start ; count < end ; count += step)
{
printf(“count = %dn”,count);
}
คราวนี้ เราลองมาทดลองเขียนโปรแกรม โดยให้โปรแกรม สามารถรับค่าตัวเลขใดๆ และแสดงค่าในรูปแบบดังตัวอย่างต่อไปนี้
Input the number > 4
0
0 1
0 1 2
0 1 2 3
0 1 2
0 1
0
เราสามารถแก้ปัญหาข้างต้น โดยใช้โครงสร้างการเขียนโปรแกรมแบบวนซ้ำดังต่อไปนี้
#include <STDIO.H>
void main()
{
int number, i, j;
printf("Enter number: ");
scanf("%d", &number);
for(j= 0; j< number; j++)
{
for(i=0; i<= j; i++)
{
printf("%d ", i);
}
printf("n");
}
for(j= number-1; j>= 0; j--)
{
for(i=0; i< j; i++)
{
printf("%d ", i);
}
printf("n");
}
}
โครงสร้างการเขียนโปรแกรมแบบวนซ้ำโดยใช้คำสั่ง do-while
รูปแบบของการเขียน code สำหรับโปรแกรมแบบวนซ้ำที่ใช้ do-while สามารถเขียนให้อยู่ในรูปทั่วไปได้ดังนี้
do
statement
while ( เงื่อนไข );
ตัวอย่างของโครงสร้าง do-while สามารถเขียนได้ดังนี้
sum = 0.0;
scanf(“%f”, &x);
do {
sum += x;
scanf(“%f”, &x);
}
while (x > 0.0);
โปรแกรมข้างต้นจะทำการอ่านค่าจะ keyboard เมื่อ User พิมพ์ค่าที่มีค่ามากกว่าศูนย์ ก็จะทำการบวกค่าเหล่านี้ไปที่ตัวแปร sum จนกระทั่ง User พิมพ์ ตัวเลข 0 หรือค่าที่น้อยกว่า ศูนย์ ทำให้เงื่อนไขเป็นเท็จ และโปรแกรมจึงจะออกจากโครงสร้าง do-while
คราวนี้เราลองมาเขียนโปรแกรมที่ใช้โครงสร้าง do-while โดยโจทย์กำหนดให้ว่า ให้โปรแกรมสามารถรับค่าตัวเลขใดๆ (X) และ แสดงผลของตัวเลข ระหว่าง 0 ถึง X ที่สามารถหารด้วย 4 ลงตัว
#include <STDIO.H>
void main()
{
int number, i;
printf("enter the numbern");
scanf("%d", &number);
i = 0;
do
{
if((i % 4) == 0) printf("%d ", i);
i++;
}
while(i <= number);
}
ตอนนี้ผู้อ่านก็คงจะรู้จัก การเขียนโปรแกรมแบบวนซ้ำกันแล้วนะ ต่อไป เราก็จะไปเรียนรู้เกี่ยวกับการเขียนโปรแกรมแบบแยกเป็นโมดูลกัน
4.ฟังก์ชัน และการเขียนโปรแกรมแยกเป็นโมดูล (Functions & Modular Programming)
สำหรับนักพัฒนา ที่ได้ทำการพัฒนาโปรแกรมมามากๆ บางครั้ง จำเป็นต้องเขียนโปรแกรมที่มีขนาดใหญ่และมีความสลับซับซ้อน จึงจำเป็นต้องหาวิธีในการพัฒนาโปรแกรมที่ดี ซึ่งสามารถทำได้ด้วยการ แตกปัญหาใหญ่ออกเป็นปัญหาย่อยๆ แล้วแก้ปัญหาย่อยออกไปที่ละส่วนจนกว่าจะหมด ซึ่งจะช่วยให้แก้ปัญหาใหญ่ๆ ได้สำเร็จนั่นเอง ซึ่งเราเรียกกันว่า วิธีแบ่งแยกแล้วพิชิต (Divide and Conquer) ซึ่งจะเป็นแนวการแก้ปัญหาแบบจากบนลงล่าง (Top down approach) ดังแสดงให้เห็นดังภาพที่ 4.1
การแตกปัญหาออกเป็นฟังก์ชันย่อยๆ มีข้อดีดังนี้
1) การแยกปัญหาที่จะใช้ในการเขียนโปรแกรมออกเป็นฟังก์ชันย่อยๆ จะช่วยให้เขียนโปรแกรมได้ง่ายขึ้นเพราะปัญหามีความซับซ้อนน้อยลง
2) การแยกปัญหาที่จะใช้ในการเขียนโปรแกรมออกเป็นฟังก์ชันย่อยๆ สามารถแก้ปัญหาตามที่โปรแกรมต้องทำ โดยมีโอกาสที่จะผิดพลาดน้อยลงเนื่องจากได้ทดสอบแก้ไขข้อผิดพลาดภายในฟังก์ชันย่อยๆ ก่อนรวมกันเป็นโปรแกรมใหญ่แล้ว
3) การแยกปัญหาออกเป็นฟังก์ชันย่อยนั้นมีประโยชน์ ที่ทำให้เราสามารถใช้ฟังกชันย่อยๆ เหล่านี้กลับไปใช้กับโปรแกรมอื่นๆ ได้ด้วย
4) การนำฟังกชันย่อยๆ เหล่านี้กลับมาใช้อีก จะช่วยลดขนาดของโปรแกรมลง และยังช่วยลดเวลาและค่าใช้จ่ายในการพัฒนาและการซ่อมบำรุงโปรแกรมได้อีกด้วย เพราะไม่ต้องเสียเวลาในการเขียนฟังก์ชันซ้ำ นอกจากฟังก์ชันย่อยที่ยังไม่ได้เขียนมาก่อน
ตัวอย่างการเขียนโปรแกรมออกเป็นโมดูลต่างๆ จะแสดงให้เป็นดังผังในภาพที่ 4.2 ซึ่งในภาพดังกล่าวได้แยกโปรแกรม Main ออกเป็นส่วนๆ คือ
1) ส่วนรับข้อมูล (Input) ซึ่งจะเป็นไปตามความต้องการของผู้ใช้ เช่นการป้อนข้อมุล หรือ การอ่านไฟล์ข้อมูล
2) ส่วนการคำนวณ (CAL) ซึ่งประกอบด้วยฟังก์ชันที่ใช้กับการคำนวณ ได้แก่
i. AVG สำหรับคำนวณค่าเกรดเฉลี่ยสำหรับเทอมปัจจุบัน
ii. GPA สำหรับคำนวณเกรดเฉลี่ยสะสม
3) ส่วนการแสดงผล (Display) ซึ่งเป็นการแสดงผลบนจอภาพ หรือจะพิมพ์ผลออกมาก็ได้ตามความต้องการของผู้ใช้โปรแกรม ที่กำหนดให้ผู้เขียนโปรแกรมทำให้สำเร็จตามเป้าหมาย
ภาพที่ 4.2: ตัวอย่างการเขียนโปรแกรมคำนวณค่าเกรดเฉลี่ย และ เกรดเฉลี่ยสะสมออกเป็นโมดูล
ส่วนในการตั้งชื่อฟังก์ชันนั้น ก็มีข้อกำหนดดังนี้
1) ห้ามขึ้นต้นด้วยตัวเลข
2) ห้ามเอาชื่อตารางอาเรย์ ชื่อตัวแปร หรือ คำสำคัญ (keywords) มาตั้งชื่อฟังก์ชันโดยเด็ดขาด
3) ในการใช้งานจริง นั้น ไม่ควรตั้งชื่อฟังก์ชันโดยไม่สื่อความหมายถึงการทำงานของฟังก์ชัน เพราะจะทำให้ลำบากในการซ่อมบำรุงโปรแกรม
โดยทั่วไปแล้วในการประกาศฟังก์ชันนั้น จะต้องมีการกำหนด type ให้ตัวแปรร่วมภายในฟังก์ชันด้วยเสมอ ดังตัวอย่างต่อไปนี้
ชนิดของฟังก์ชัน[function-type] ชื่อฟังก์ชัน [function-name] (บัญชีตัวแปรร่วม [parameter-list])
{
การประกาศตัวแปรเฉพาะที่; [local-definitions declaration;]
กลไกการทำงานของฟังก์ชัน; [function-implementation;]
การคืนค่าถ้าชนิดฟังก์ชันไม่เป็น void; [return statement if function type NOT void]
}
ยกตัวอย่างเช่น
float distance(float x, float y) // float คือ ชนิดของฟังก์ชัน ส่วน distance คือ ชื่อฟังก์ชัน
{ // float x, float y คือ บัญชีตัวแปรร่วม
float dist; // float dist คือ การประกาศตัวแปรเฉพาะที่;
dist = sqrt(x*x+y*y); // dist = ระยะห่างระหว่างพิกัด (x,y) ไป (0,0)
return dist ;
}
ก่อนจะทำการเรียกใช้ฟังก์ชัน จำเป็นต้องมี การกำหนดฟังก์ชัน (function prototype)
ซึ่งเป็น copy ของ function heading และมีข้อกำหนดดังนี้
1) ตัวแปรร่วมในฟังก์ชัน ที่ประกาศไว้ และ ตัวแปรร่วมขณะเรียกใช้ฟังกชันนั้นต้องมีจำนวนเท่ากันและต้องมี type ตรงกัน มิฉะนั้นจะเกิด error ขึ้น
2) ต้องกำหนดการทำงานของฟังก์ชันก่อนการเรียกใช้ฟังก์ชัน ใน main function เพื่อให้ตัวแปรภาษารู้ว่าฟังก์ชันนี้ทำงานอย่างไร
3) แม้ฟังก์ชันที่ใช้จะไม่มีค่าตัวแปรร่วม ก็ต้องใส่วงเล็บ [ ( ) ] ไว้หลังชื่อฟังก์ชันเสมอ
4) การกำหนดฟังก์ชัน จะต้องกำหนดก่อนการใช้ Main function เพื่อให้ Main function ได้รับรู้ว่าฟังก์ชันดังกล่าวมีอะไรเป็นตัวแปรร่วม และ จะคืนค่าอะไรออกมา
5) กลไกการทำงานเต็มของฟังก์ชันย่อยจะแสดงหลังจากที่เรียก Main function แล้ว หรืออยู่ในไฟล์ที่แยกต่างหาก ซึ่งจะมีการแปรออกมาแล้วเชื่อมต่อกับ Main function
การกำหนดฟังก์ชันจะมีลักษณะดังนี้
float distance(float, float); // การกำหนดฟังก์ชัน [function prototype]
void main()
{
float x0 = ….,y0 = …;
float dist1 = distance(x0,y0);
}
float distance(float x, float y) // float คือ ชนิดของฟังก์ชัน distance คือ ชื่อฟังก์ชัน
{ // float x, float y คือ บัญชีตัวแปรร่วม
float dist; // float dist คือ การประกาศตัวแปรเฉพาะที่;
dist = sqrt(x*x+y*y);
return dist ;
}
ในการส่งผ่านตัวแปรเข้า ฟังก์ชัน (Passing argument)
นั้นมีการเรียกได้ 2 แบบ คือ
1) ส่งผ่านตามค่า (Pass by Value) ซึ่งส่งผ่านค่า ลงในตัวแปรร่วมของฟังก์ชันโดยตรง
2) ส่งผ่านตามการอ้างอิง (pass by Reference) ซึ่งส่งผ่านค่า address ในหน่วยความจำของตัวแปร ให้กับตัวแปรร่วมของฟังก์ชัน ถ้ามีการเปลี่ยนแปลงข้อมูล ณ ตำแหน่งหน่วยความจำดังกล่าว ค่าที่ส่งให้ตัวแปรร่วมของฟังก์ชันก็จะเปลี่ยนด้วย
ตัวแปรที่เกี่ยวข้องกับฟังก์ชันคือ
1) ตัวแปรเฉพาะที่ (Local variables) เป็นตัวแปรที่อยู่และเปลี่ยนแปลงเฉพาะภายในฟังก์ชันที่เรียกใช้ตัวแปรดังกล่าว การเปลี่ยนแปลงภายนอกฟังก์ชันที่เรียกใช้ตัวแปรเฉพาะที่จะไม่มีผลต่อตัวแปรเฉพาะที่ดังกล่าว ดังตัวอย่างต่อไปนี้
void test_locvar(int num)
{
int myvar; // Local variable fro this function
myvar = num;
}
void main()
{
int myvar, myvar_before, myvar_after; //Local variable for this function
myvar = 5;
myvar_before = myvar; // myvar_before = 5;
test_locvar(100); // call function
myvar_after = myvar; // myvar_after = 5;
}
2) ตัวแปรส่วกลาง (Global variables) เป็นตัวแปรที่อยู่นอกฟังก์ชันซึสามารถเปลี่ยแปลงค่าภายในตัวแปรได้ตลอดเวลาเมื่อตัวแปรได้รับการเปลี่ยนแปลงโดยฟังก์ชัน ดังตัวอย่างต่อไปนี้
int myvar; // Global varible
void test_locvar(int num)
{
myvar = 20;
}
void main()
{
int myvar_before, myvar_after; //Local variable fro this function
myvar = 5;
myvar_before = myvar; // myvar_before == 5;
test_locvar(100); // call function
myvar_after = myvar; // myvar_after == 20;
}
ฟังก์ชันมีหลายประเภทได้แก่
1) ฟังก์ชันที่ไม่มี อาร์กิวเมนต์ และ ไม่คืนค่า เช่น ฟังก์ชัน void main()
2) ฟังก์ชันที่มี อาร์กิวเมนต์ แต่ ไม่คืนค่า เช่นฟังก์ชัน void do_something(float x, float y) ซึ่งจะทำงานตามที่ต้องการโดยอาศัยค่าอาร์กิวเมนต์ (ตัวแปร x,y) โดยไม่คืนค่าออกมา ฟังก์ชันดังกล่าวจะมีกลไกการับข้อมูลเข้าต่างหาก โดยไม่ต้องใช้ตัวแปรที่เป็น อาร์กิวเมนต์
3) ฟังก์ชันที่ไม่มี อาร์กิวเมนต์ แต่ก็คืนค่า เช่น ฟังก์ชัน float do_something2() ค่าที่คืนมาได้จาก ตัวแปรเฉพาะที่และกลไกการคำนวณภายในฟังก์ชันดังกล่าว
4) ฟังก์ชันที่มี อาร์กิวเมนต์ และ คืนค่า เช่นฟังก์ชัน float distance(float x, float y) ฟังก์ชันดังกล่าว สามารถคืนค่า โดยไม่จำเป็นต้องใช้ตัวแปรเฉพาะที่ทำหน้าที่เป็นตัวแปรชั่วคราวในการคืนค่า ตัวอย่างเช่น
float distance3D(float x, float y, float z)
{
return sqrt((x*x)+(y*y)+(z*z));
1.1 ขั้นตอนวิธีการทางคอมพิวเตอร์ (computer algorithms)
ก่อนที่เราจะเขียนโปรแกรมคอมพิวเตอร์ภาษาใดภาษาหนึ่งเพื่อแก้ปัญหาทางคอมพิวเตอร์ เราควรศึกษาขั้นตอนวิธีการทางคอมพิวเตอร์ เพื่อให้เกิดความรู้ความเข้าใจที่ถูกต้องตามขั้นตอนวิธีดังนี้
1) การวิเคราะห์งาน (job analysis)
2) การเขียนผังงานโปรแกรม (program flowcharting)
3) การเขียนโปรแกรม (programming)
4) การทดสอบ และแก้ไขโปรแกรม (testing and editing program)
5) การจัดทำเอกสารประกอบ และการบำรุงรักษาโปรแกรม (documentation and maintenance program)
1.1.1 การวิเคราะห์งาน (job analysis)
ในการวิเคราะห์งานเราจะต้องกำหนดจุดประสงค์ของการวิเคราะห์งาน และขั้นตอนวิธีการวิเคราะห์งานแต่ละอย่างให้ได้ ซึ่งงานแต่ละอย่างมีรายละเอียดดังนี้
1.1.1.1 จุดประสงค์ของการวิเคราะห์งาน
ในการวิเคราะห์งานแต่ละอย่างมีจุดประสงค์ของการวิเคราะห์งานที่สำคัญดังนี้
1. เพื่อหาวัตถุประสงค์ของการเขียนโปรแกรม
2. เพื่อหารูปแบบผลลัพธ์ที่ต้องการ
3. เพื่อหาข้อมูลนำเข้าที่ต้องใส่เข้าไปในโปรแกรม
4. เพื่อหาตัวแปรที่จำเป็นต้องใช้ในโปรแกรม
5. เพื่อหาขั้นตอนวิธีการทำงานของโปรแกรม
1.1.1.2 ขั้นตอนวิธีการวิเคราะห์งาน
ในการวิเคราะห์งานแต่ละอย่างมีขั้นตอนวิธีการวิเคราะห์งานที่สำคัญดังนี้
1) การหาวัตถุประสงค์ของการเขียนโปรแกรม
ผู้เขียนโปรแกรมจะต้องหาวัตถุประสงค์จากงานที่จะเขียนโปรแกรมว่า ต้องการเขียนโปรแกรมเพื่อแก้ปัญหาอะไรบ้างซึ่งจะทำให้เขียนโปรแกรมได้ตรงกับความต้องการหรือวัตถุประสงค์ของงานนั้น ๆ
2) การหารูปแบบผลลัพธ์ที่ต้องการ
เมื่อผู้เขียนโปรแกรมหาวัตถุประสงค์ของการเขียนโปรแกรมได้แล้ว ขั้นตอนต่อมาคือการกำหนดรูปแบบผลลัพธ์ที่ต้องการจากโปรแกรม ซึ่งรูปแบบผลลัพธ์อาจอยู่ในลักษณะของข้อความหรือตัวเลข หรือตาราง หรือแผนภูมิ หรืออาจใช้ผสมกันระหว่างตัวเลขกับข้อความ หรือข้อความกับตัวเลข และตารางก็ได้ ขึ้นอยู่กับผู้เขียนโปรแกรมเป็นผู้กำหนดเอง แต่โดยส่วนมากนิยมแสดงผลลัพธ์ของโปรแกรมให้อยู่ในรูปแบบที่เข้าใจง่ายมากกว่ารูปแบบที่ซับซ้อน
3) การหาข้อมูลนำเข้าที่ต้องใส่เข้าไปในโปรแกรม
ผู้เขียนโปรแกรมจะต้องหาข้อมูลนำเข้าจากผลลัพธ์ที่ได้จากโปรแกรม โดยคำนึงถึงขั้นตอนวิธีการคำนวณ และข้อมูลที่จำเป็นต้องใส่เข้าไปเพื่อให้ได้ผลลัพธ์ที่ต้องการ
ตัวอย่างที่ 1.1 ผลลัพธ์ที่ต้องการ คือ พื้นที่สามเหลี่ยมมุมฉากข้อมูลนำเข้าที่ต้องใส่เข้าไปในโปรแกรมคือ
1) สูตรคำนวณพื้นที่สามเหลี่ยมมุมฉาก
พื้นที่สามเหลี่ยมมุมฉาก = ? x ฐาน x สูง
2) ความยาวของฐานและความสูงของรูปสามเหลี่ยม
4) การหาตัวแปรที่จำเป็นต้องใช้ในโปรแกรม
ตัวแปร หมายถึง ชื่อที่ผู้เขียนโปรแกรมสามารถตั้งขึ้นเองตามหลักการตั้งชื่อตัวแปรของภาษาคอมพิวเตอร์ที่นำมาเขียนโปรแกรม (หลักเกณฑ์การตั้งชื่อตัวแปรกล่าวไว้ในหัวข้อ 2.5.3.1) เพื่อใช้ในการอ้างอิงการเก็บข้อมูลและเรียกใช้ข้อมูลภายในตัวแปร ดังนั้นผู้เขียนโปรแกรมจะต้องตั้งชื่อตัวแปรที่ใช้ในการเก็บข้อมูลทั้งหมดภายในโปรแกรม รวมถึงตัวแปรบางตัวที่ใช้ในการนับจำนวนรอบของการทำงานในโปรแกรมอีกด้วย
|
5) การหาขั้นตอนวิธีการทำงานของโปรแกรม
การหาขั้นตอนวิธีการทำงานของโปรแกรมจะขึ้นอยู่กับลักษณะของการแก้ปัญหา ดังนั้นนักเขียนโปรแกรมที่มีความชำนาญในระดับหนึ่งแล้วจะสามารถหาขั้นตอนวิธีการทำงานของโปรแกรมได้โดยไม่ยาก แต่สำหรับผู้ที่เริ่มต้นศึกษาการเขียนโปรแกรม ควรหาขั้นตอนวิธีการทำงานของโปรแกรมตามคำแนะนำโดยเรียงตามลำดับดังนี้
ขั้นตอนวิธีการทำงานของโปรแกรมที่แนะนำ
|
5.1) เริ่มต้นทำงาน |
ทั้งนี้การวิเคราะห์งานเพื่อแก้ปัญหาแต่ละอย่างอาจมีบางขั้นตอนแตกต่างกันไป ดังนั้นคำแนะนำข้างต้นจึงเป็นเพียงแนวทางของการหาขั้นตอนวิธีการทำงานของโปรแกรมเท่านั้น ซึ่งเวลาใช้งานจริงผู้วิเคราะห์งานต้องประยุกต์ให้เข้ากับปัญหาที่ต้องการแก้ไขต่อไป
เพื่อความเข้าใจเกี่ยวกับขั้นตอนวิธีการวิเคราะห์งานมากยิ่งขึ้น ให้ศึกษาจากตัวอย่างการวิเคราะห์งานดังต่อไปนี้
ตัวอย่างที่ 1.2 จงเขียนวิเคราะห์งาน เพื่อเขียนโปรแกรมคำนวณ พื้นที่สี่เหลี่ยมผืนผ้า จำนวน 1 รูป โดยที่ผู้ใช้โปรแกรม จะต้องป้อนความกว้าง และความยาวของสี่เหลี่ยมผืนผ้า เข้าไปในโปรแกรม
วิธีทำ
ขั้นตอนการวิเคราะห์งานทั้ง 5 ขั้นตอน สามารถแสดงได้ดังนี้
1) วัตถุประสงค์ของการเขียนโปรแกรม
เพื่อคำนวณพื้นที่สี่เหลี่ยมผืนผ้าจำนวน 1 รูป
2) รูปแบบผลลัพธ์ที่ต้องการ
พิมพ์ผลลัพธ์ออกทางจอภาพ ดังนี้
3) ข้อมูลนำเข้า
3.1) สูตรคำนวณพื้นที่สี่เหลี่ยมผืนผ้า
Area = Width*Length
3.2) รับค่าความกว้างและความยาวของสี่เหลี่ยมผืนผ้าผ่านทางคีย์บอร์ด
4) ตัวแปรที่ตั้งขึ้นเพื่อใช้ในโปรแกรม
Width = ตัวแปรที่ใช้เก็บความกว้างของสี่เหลี่ยมผืนผ้า
Length = ตัวแปรที่ใช้เก็บความยาวของสี่เหลี่ยมผืนผ้า
Area = ตัวแปรที่ใช้เก็บพื้นที่ของสี่เหลี่ยมผืนผ้า
โดยคำนวณได้จากสูตร Area = Width*Length
5) ขั้นตอนวิธีการทำงานของโปรแกรมมีดังนี้
5.1) เริ่มต้นทำงาน
5.2) รับข้อมูลค่าความยาวและความกว้างของสี่เหลี่ยมผืนผ้าผ่านทางคีย์บอร์ด
5.3) คำนวณพื้นที่สี่เหลี่ยมผืนผ้าตามสูตร
Area = Width*Length
5.4) พิมพ์ค่าความยาว ความกว้าง และพื้นที่สี่เหลี่ยมผืนผ้าออกทางจอภาพ
5.5) จบการทำงาน
1.1.2 การเขียนผังงานโปรแกรม (program flowcharting)
สำหรับหัวข้อการเขียนผังงานโปรแกรมจะประกอบด้วยเนื้อหาที่สำคัญดังนี้คือ ความหมายของผังงาน ประเภทของผังงาน สัญลักษณ์มาตรฐานที่ใช้เขียนผังงานโปรแกรม หลักการเขียนผังงานโปรแกรม และขั้นตอนการเขียนผังงานโปรแกรม ดังรายละเอียดต่อไปนี้
1.1.2.1 ความหมายของผังงาน
“ผังงาน” (flowchart) ทางคอมพิวเตอร์ หมายถึง แผนภาพที่เขียนขึ้นโดยใช้สัญลักษณ์มาตรฐาน เพื่อแสดงขั้นตอนวิธีการทำงานของโปรแกรม หรือระบบงานที่ต้องการ
1.1.2.2 ประเภทของผังงาน
ผังงานสามารถจำแนกออกได้ 2 ประเภท คือ
1) ผังงานระบบ (system flowchart) หมายถึง ผังงานที่แสดงถึงขั้นตอนวิธีการทำงานของระบบงานใดระบบหนึ่ง ซึ่งในผังงานระบบจะแสดงให้เห็นถึงสื่อที่ใช้รับข้อมูล บันทึกข้อมูล วิธีการประมวลผล ขั้นตอนการทำงานและความสัมพันธ์ของส่วนต่าง ๆ ในระบบงานอย่างกว้าง ๆ เพื่อให้เห็นภาพรวมของระบบงานใดระบบงานหนึ่ง เช่น
รูปที่ 1.1 ผังงานระบบแสดงการตัดเกรด
ที่มา :กรรณิการ์ กมลรัตน์, 2547.
2) ผังงานโปรแกรม (program flowchart) หมายถึงผังงานที่แสดงขั้นตอน วิธีการทำงานของโปรแกรมที่ต้องการเขียนขึ้น ภายในผังงานโปรแกรม จะแสดงให้เห็นขั้นตอน วิธีการทำงาน ของโปรแกรมอย่างละเอียด เพื่อให้คอมพิวเตอร ์สามารถทำงานตามที่เขียนไว้ในผังงานโปรแกรม ได้อย่างถูกต้อง โดยเราสามารถนำขั้นตอน วิธีการทำงานของโปรแกรมในขั้นการวิเคราะห์งาน มาเขียนเป็นผังงานโปรแกรมได้ทันที จากนั้นก็สามารถนำผังงานโปรแกรม ไปเขียนโปรแกรมตามที่ต้องการได้ ดังนั้นในเรื่องของการเขียนผังงาน ที่จะกล่าวต่อไปนี้จะเกี่ยวข้องกับผังงานโปรแกรมทั้งสิ้น เช่น
รูปที่ 1.2 ผังงานโปรแกรมแสดงรายละเอียดการทำงานของโปรแกรมสำหรับตัดเกรด
ที่มา :เฉลิมพล ทัพซ้าย, 2530 : 29.
1.2.1.3 สัญลักษณ์มาตรฐานที่ใช้เขียนผังงานโปรแกรม
สถาบันมาตรฐานแห่งชาติของสหรัฐอเมริกา (American National Standard Institute) และองค์การระหว่างประเทศว่าด้วยการมาตรฐาน (International Organization for Standardization) ได้ร่วมกันกำหนดสัญลักษณ์มาตรฐานที่ใช้เขียนผังงานโปรแกรม
โดยในเอกสารเล่มนี้จะนำเสนอสัญลักษณ์ที่นิยมนำมาใช้เขียนผังงานโปรแกรม ดังต่อไปนี้
1. สัญลักษณ์ Process
|
Process
|
ความหมายของ Process คือ การกำหนดค่าหรือการคำนวณค่า
ตัวอย่างที่ 1.3 แสดงการกำหนดค่าให้ตัวแปร Total
ตัวอย่างที่ 1.4 แสดงการคำนวณค่าผลรวมของตัวแปร Total
2. สัญลักษณ์ Decision
ความหมายของ Decision คือ การทดสอบเงื่อนไขหรือเปรียบเทียบเงื่อนไข เพื่อตัดสินใจทำงานอย่างใดอย่างหนึ่งตามที่ต้องการ
ตัวอย่างที่ 1.5 แสดงการเปรียบเทียบเงื่อนไข 1 ทางเลือก
ตัวอย่างที่ 1.6 แสดงการเปรียบเทียบเงื่อนไข 2 ทางเลือก
3. สัญลักษณ์ Start/ Stop program หรือ Terminal Interrupt
ความหมายของสัญลักษณ์ คือ การเริ่มต้นโปรแกรม หรือการสิ้นสุดการทำงานของโปรแกรม หรือหยุดการทำงานชั่วคราว
ตัวอย่างที่ 1.7 แสดงการใช้งานสัญลักษณ์ Start/ Stop program หรือ Terminal Interrupt
4. สัญลักษณ์ Input / Output
ความหมายของสัญลักษณ์ คือ การรับข้อมูล (input) หรือการแสดงผลลัพธ์ (output) โดยไม่ได้ระบุสื่อที่ใช้
ตัวอย่างที่ 1.8 แสดงการใช้งานสัญลักษณ์ Input/ Output
5. สัญลักษณ์ Display
ความหมายของสัญลักษณ์ คือ การแสดงผลลัพธ์ทางจอภาพ
ตัวอย่างที่ 1.9 แสดงการใช้งานสัญลักษณ์ display
6. สัญลักษณ์ Document
ความหมายของสัญลักษณ์ คือ การพิมพ์ผลลัพธ์ออกทางกระดาษพิมพ์
ตัวอย่างที่ 1.10 แสดงการใช้งานสัญลักษณ์ Document
7. สัญลักษณ์ Manual Input
ความหมายของสัญลักษณ์ คือ การรับข้อมูลหรือคำสั่งผ่านทางคีย์บอร์ด
ตัวอย่างที่ 1.11 แสดงการใช้งานสัญลักษณ์ Manual Input
8. สัญลักษณ์ Manual Operation
ความหมายของสัญลักษณ์คือการรับข้อมูลหรือแสดงผลลัพธ์โดยไม่ระบุสื่อ
ตัวอย่างที่ 1.12 แสดงการใช้งานสัญลักษณ์ Manual Operation
9. สัญลักษณ์ Connector
Connector
ความหมายของสัญลักษณ์ คือ แสดงจุดเชื่อมต่อจากที่หนึ่งไปยังอีกที่หนึ่งของผังงาน โดยที่จุดเชื่อมต่อนี้อยู่ในหน้าเดียวกัน
ตัวอย่างที่ 1.13 แสดงการใช้งานสัญลักษณ์ Connector
10. สัญลักษณ์ Off page Connector
Off page Connector
ความหมายของสัญลักษณ์ คือ แสดงจุดเชื่อมต่อจากที่หนึ่งไปยังอีกที่หนึ่งของผังงาน โดยที่จุดเชื่อมต่อนี้อยู่ต่างหน้ากัน
ตัวอย่างที่ 1.14 แสดงการใช้งานสัญลักษณ์ Off page Connector
คำนวณค่า Avg = Total + N เสร็จแล้ว ไปทำงานต่อไปที่จุด B โดยที่จุด B อยู่ต่างหน้ากัน
11. สัญลักษณ์ flow line and arrowheads
ความหมายของสัญลักษณ์ คือ แสดงทิศทาง การทำงานของผังงาน โดยใช้ลูกศร เป็นตัวกำหนดทิศทาง การทำงานของผังงาน
ตัวอย่างที่ 1.15 แสดงการใช้งานสัญลักษณ์ flow line and arrowheads
12. สัญลักษณ์ Punched Card
ความหมายของสัญลักษณ์คือการรับข้อมูลหรือแสดงผลลัพธ์บนบัตรเจาะรู
ตัวอย่างที่ 1.16 แสดงการใช้งานสัญลักษณ์ Punched Card
1.1.2.4 หลักการเขียนผังงานโปรแกรม
การเขียนผังงานโปรแกรม มีหลักการเขียนดังนี้
1) เขียนผังงานจากด้านบนลงด้านล่าง
2) ใช้สัญลักษณ์ให้ตรงกับความหมายของผังงาน
3) ใช้เส้น flow line และ arrowheads แสดงทิศทางการทำงานของผังงาน
4) ใส่คำอธิบายลงในสัญลักษณ์สั้น ๆ แต่เข้าใจง่าย จะใช้ภาษาไทยหรืออังกฤษก็ได้
5) หลีกเลี่ยงการโยงเส้นทิศทางของผังงานให้ตัดกันเพราะจะทำให้สับสน ควรใช้จุดเชื่อมต่อ (connector) หน้าเดียวกันแทน จะเข้าใจได้ง่ายและเป็นระเบียบ
6) พยายามเขียนผังงานให้จบในหน้ากระดาษเดียวกัน แต่ถ้าไม่จบในหน้าเดียวกัน ควรใช้จุดเชื่อมต่อต่างหน้ากระดาษ (off page connector)
1.1.2.5 ขั้นตอนการเขียนผังงานโปรแกรม
เพื่อความเข้าใจเกี่ยวกับขั้นตอนการเขียนผังงานโปรแกรมได้ถูกต้องให้ศึกษาจากตัวอย่างดังต่อไปนี้
ตัวอย่างที่ 1.17 จงเขียนผังงานโปรแกรมที่ได้วิเคราะห์งานมาแล้วในตัวอย่าง
ที่ 1.2
วิธีทำ
จากการวิเคราะห์งานในตัวอย่างที่ 1.2 จะได้ว่า
ขั้นตอนวิธีการทำงานของโปรแกรม มีดังนี้
1) เริ่มต้นทำงาน
2) รับข้อมูลค่าความยาว และความกว้างของสี่เหลี่ยมผืนผ้าผ่านทางคีย์บอร์ด
3) คำนวณพื้นที่สี่เหลี่ยมผืนผ้าตามสูตร Area = Width * Length
4) พิมพ์ค่าความยาว ความกว้าง และพื้นที่สี่เหลี่ยมผืนผ้าออกทาง จอภาพ
5) จบการทำงาน
การเขียนผังงานโปรแกรม จะนำขั้นตอนวิธีการทำงานของโปรแกรม ที่ได้จากการวิเคราะห์งาน มาเขียนผังงานได้ดังนี้
รูปที่ 1.3 แสดงผังงานขั้นตอนวิธีการทำงานของโปรแกรม
ที่มา :สมชาย รัตนเลิศนุสรณ์, 2545 : 17.
1.1.3 การเขียนโปรแกรม (programming)
ในหัวข้อเรื่องการเขียนโปรแกรมจะกล่าวถึงเนื้อหา 2 ส่วน คือความหมายของโปรแกรมคอมพิวเตอร์ และภาษาคอมพิวเตอร์ดังมีรายละเอียดต่อไปนี้
1.1.3.1 ความหมายของโปรแกรมคอมพิวเตอร์
โปรแกรมคอมพิวเตอร์ (computer program) หมายถึง ชุดของคำสั่งที่เขียนขึ้นเพื่อสั่งให้คอมพิวเตอร์ทำงานตามที่ต้องการ ส่วนการเขียนโปรแกรม (programming) หมายถึง การเขียนชุดคำสั่งด้วยภาษาคอมพิวเตอร์ภาษาใดภาษาหนึ่ง เพื่อให้คอมพิวเตอร์ทำงานตามโปรแกรมที่เราเขียนขึ้น
ดังนั้น ผู้เขียนโปรแกรม (programmer) จึงจำเป็นต้องเรียนรู้ภาษาคอมพิวเตอร์ภาษาใดภาษาหนึ่งหรือหลายภาษา แล้วฝึกฝนทักษะการเขียนโปรแกรมด้วยภาษาคอมพิวเตอร์ที่ต้องการใช้งานให้เกิดความชำนาญจึงจะสามารถเขียนโปรแกรมคอมพิวเตอร์ได้อย่างมีประสิทธิภาพ
1.1.3.2 ภาษาคอมพิวเตอร์
ภาษาคอมพิวเตอร์ (computer language) หมายถึง ภาษาที่สามารถนำมาใช้เขียนโปรแกรมคอมพิวเตอร์ได้ ซึ่งแต่ละภาษามีรายละเอียดดังต่อไปนี้
1) ภาษาเครื่อง (machine language)
ภาษาเครื่องจัดเป็นภาษาคอมพิวเตอร์ภาษาเดียวที่สามารถติดต่อกับคอมพิวเตอร์ได้โดยตรง เพราะว่าการเขียนคำสั่งและข้อมูลในภาษาเครื่องใช้ระบบเลขฐานสอง (binary number system) คือใช้ตัวเลข 0 และ 1 เท่านั้น ทำให้เครื่องคอมพิวเตอร์สามารถทำงานได้รวดเร็ว ส่วนข้อเสียของภาษาเครื่อง คือ เครื่องคอมพิวเตอร์ต่างชนิดกันมีลักษณะการเขียนภาษาเครื่องที่แตกต่างกันไป และเกิดความยุ่งยากในการปรับปรุงแก้ไข ทำให้เกิดความไม่สะดวกในการใช้งาน ดังนั้นภาษานี้จึงไม่เหมาะกับผู้เริ่มต้นเขียนโปรแกรม
ตัวอย่างที่ 1.18 แสดงคำสั่งของภาษาเครื่องมีดังนี้
ถ้าเราต้องการสั่งให้เครื่องทำงานตามคำสั่ง 9 + 3 แสดงได้ดังนี้
การบวกแทนด้วยรหัส 10101010
เลข 9 เปลี่ยนเป็นเลขฐานสอง 00001001
เลข 3 เปลี่ยนเป็นเลขฐานสอง 00000011
ดังนั้น คำสั่ง 9 + 3 เขียนเป็นภาษาเครื่องได้ดังนี้00001001 10101010 00000011
2) ภาษาแอสเซมบลี (assembly language)
ภาษาแอสเซมบลีหรือจะเรียกชื่ออีกอย่างว่าภาษาระดับต่ำ ซึ่งเป็นภาษาคอมพิวเตอร์ที่พัฒนาขึ้นมาเพื่อให้ผู้เขียนโปรแกรมสามารถเขียนโปรแกรมติดต่อกับคอมพิวเตอร์ได้ง่ายกว่าภาษาเครื่อง ส่วนการเขียนคำสั่งในภาษาแอสเซมบลีจะใช้คำย่อของภาษาอังกฤษและอ้างถึงตำแหน่งที่อยู่ภายในคอมพิวเตอร์เป็นส่วนใหญ่ ได้แก่ MOVE, DC, DS, CL10 เป็นต้น ผู้ที่ต้องใช้ภาษาแอสเซมบลีส่วนมากจะเป็นวิศวกรคอมพิวเตอร์ ดังนั้นภาษาแอสเซมบลีจึงไม่เหมาะกับผู้เริ่มต้นเขียนโปรแกรม
ตัวอย่างที่ 1.19 แสดงคำสั่งของภาษาแอสเซมบลีมีดังนี้
ถ้าเราต้องการสั่งให้เครื่องทำงานตามคำสั่ง 9 + 3 แสดงได้ดังนี้
MOV AX, 9
MOV BX, 3
ADD AX, BX
3) ภาษาระดับสูง (high level language)
ภาษาระดับสูงเป็นภาษาที่ผู้เขียนโปรแกรมสามารถเข้าใจได้ง่ายกว่าภาษาแอสเซมบลีและภาษาเครื่อง ทั้งนี้ก็เพราะการเขียนคำสั่งของภาษาระดับสูงมีลักษณะเป็นภาษาอังกฤษ ซึ่งอ่านแล้วเข้าใจได้ง่ายกว่าภาษาแอสเซมบลี เช่น ใช้คำว่า READ, WRITE, PRINT, COMPUTE เป็นต้น ตัวอย่างของภาษาระดับสูงได้แก่ ภาษาฟอร์แทรน (FORTRAN), ภาษาโคบอล (COBOL), ภาษาเบสิก (BASIC), ภาษาปาสคาล (PASCAL) และภาษาซี (C) เป็นต้น ซึ่งแต่ละภาษามีประวัติพอสังเขปดังต่อไปนี้
- ภาษาฟอร์แทรน (FORTRAN ย่อมาจาก FORmula TRANslator) พัฒนาโดยบริษัท IBM ระหว่างปี ค.ศ.1954 ถึง ค.ศ.1957 ภาษานี้ใช้สำหรับการพัฒนาโปรแกรมประยุกต์ด้านวิทยาศาสตร์และวิศวกรรมศาสตร์ ที่ต้องใช้ในการคำนวณสมการคณิตศาสตร์ที่ซับซ้อน ปัจจุบันภาษาฟอร์แทรนยังเป็นที่นิยมใช้ ในการพัฒนาโปรแกรมด้านวิทยาศาสตร์และวิศวกรรมศาสตร์
- ภาษาโคบอล (COBOL ย่อมาจาก Common Business Oriented Language) พัฒนาขึ้นในปี ค.ศ.1959 เป็นภาษาที่พัฒนาขึ้นมาเพื่อใช้ในการพัฒนาโปรแกรมประยุกต์ด้านธุรกิจและการค้า ปัจจุบันโปรแกรมที่ใช้ในด้านธุรกิจจำนวนมากยังเป็นโปรแกรมที่พัฒนามาจากภาษาโคบอล
- ภาษาเบสิก (BASIC ย่อมาจาก Beginners All-purpose Symbolic Instructional Code) เป็นภาษาที่พัฒนาขึ้นโดยมีจุดประสงค์เพื่อให้ผู้เริ่มต้นพัฒนาโปรแกรมสามารถเรียนรู้และเข้าใจการพัฒนาโปรแกรมอย่างง่าย ภาษาเบสิกเป็นภาษาคอมพิวเตอร์ภาษาแรกที่ใช้เครื่องไมโครคอมพิวเตอร์
ภาษาคอมพิวเตอร์ที่พัฒนาขึ้นในยุคแรก ยังมีข้อจำกัดในการที่จะพัฒนาโปรแกรมขนาดใหญ่ ทั้งนี้เนื่องจากภาษาคอมพิวเตอร์เหล่านั้นขาดโครงสร้างที่ดี ทำให้การพัฒนาโปรแกรมที่มีขนาดใหญ่และมีความซับซ้อนเป็นไปได้ยาก ในช่วงต้นปี ค.ศ.1970 จึงมีภาษาคอมพิวเตอร์ที่เป็นภาษาเชิงกระบวนการ (Procedural หรือ Structural Language) เกิดขึ้น ภาษาคอมพิวเตอร์ประเภทนี้จะมีความยืดหยุ่นในการพัฒนาโปรแกรม ทำให้สามารถแก้ไขและบำรุงรักษาได้ง่าย เนื่องจากโปรแกรมถูกแยกออกเป็นส่วน ๆ ภาษาคอมพิวเตอร์ที่เป็นภาษาเชิงกระบวนการที่สำคัญคือ
- ภาษาปาสคาล (Pascal) พัฒนาโดย Niclaus Wirth ในปี ค.ศ.1971 โดยมีจุดประสงค์เพื่อใช้ในการสอนการเขียนโปรแกรมภาษาเชิงกระบวนการ ในมหาวิทยาลัย แต่เนื่องจากภาษาปาสคาลไม่มีคุณลักษณะที่จะสนับสนุนการพัฒนาโปรแกรมด้านธุรกิจและอุตสาหกรรมจึงไม่ได้รับความนิยมมากนัก
- ภาษาซี (C) พัฒนาขึ้นในช่วงเดียวกับภาษาปาสคาล โดยนักวิจัยที่ห้องปฏิบัติการ AT&T Bell ซึ่งได้นำเอาจุดเด่นของภาษา BCPL และภาษา B มาใช้และได้เพิ่มคุณลักษณะและชนิดข้อมูลอื่นเข้ามาด้วย เดิมภาษาซีถือว่าเป็นภาษาคอมพิวเตอร์ที่สำคัญในการพัฒนาโปรแกรมบนระบบปฏิบัติการยูนิกส์ (Unix) ซึ่งเป็นภาษาคอมพิวเตอร์ที่สามารถสร้างโปรแกรมประยุกต์ที่ทำงานได้รวดเร็วมาก เมื่อเทียบกับภาษาคอมพิวเตอร์อื่น ๆ
4) ภาษาระดับสูงมาก (very high level language)
ภาษาระดับสูงมาก บางครั้งเรียกว่า Fourth Gerneration Languages (4GLs) เป็นภาษาที่มีลักษณะสำคัญ คือ ผู้เขียนโปรแกรมไม่ต้องบอกวิธีการทำงานโดยละเอียด เพียงแต่ระบุคำสั่งให้ทำงานสั้น ๆ ให้ภาษาระดับสูงมากเข้าใจก็เพียงพอ ส่วนวิธีการคำนวณหรือการทำงานภาษาระดับสูงมากจะเป็นผู้จัดการเองทั้งสิ้น บางครั้งเรียกว่า non-procedure language
ตัวอย่างภาษาระดับสูงมาก ได้แก่ ภาษา SQL (Structured Query Langauge) ซึ่งนิยมใช้กันในซอร์ฟแวร์พัฒนาระบบจัดการฐานข้อมูล เช่น ORACLE เป็นต้น
5) ภาษาระดับธรรมชาติ (natural language)
ภาษาธรรมชาติจะเกี่ยวข้องกับระบบฐานความรู้ (knowledge based system ) และกฎอ้างอิง (inference rules) เพียงแต่ผู้ใช้ภาษาธรรมชาติป้อนคำถามผ่านเข้าไปในคอมพิวเตอร์ที่มีภาษาธรรมชาติก็จะทำการวิเคราะห์คำถามแล้วไปค้นหาคำตอบจากระบบฐานความรู้ที่เก็บไว้
ตัวอย่างของภาษาธรรมชาติ ได้แก่ ภาษา PROLOG และภาษา LISP (List Processing Language)
1.1.4 การทดสอบ และแก้ไขโปรแกรม (testing and editing program)
หลังจากที่เราเขียนโปรแกรมเสร็จแล้ว ขั้นตอนต่อไป คือ การทดสอบโปรแกรมที่เขียนขึ้นซึ่งอาจพบความผิดพลาดได้ 2 ชนิด ดังนี้
1) ความผิดพลาดทางไวยากรณ์ภาษา (syntax error) เป็นความผิดพลาดที่เกิดจากการเขียนคำสั่งของภาษาคอมพิวเตอร์ผิด ตัวอย่างเช่น คำสั่ง printf( ) ในภาษา C ต้องเขียนด้วยตัวอักษรตัวเล็ก แต่เขียนเป็น PRINTF( ) เป็นต้น โดยส่วนมากความผิดพลาดทางไวยากรณ์ จะถูกตรวจสอบพบเมื่อมีการแปลโปรแกรม (compile) ให้เป็นภาษาเครื่อง ซึ่งเราสามารถแก้ไขโดยการเขียนคำสั่งให้ถูกต้องตามไวยากรณ์ของภาษานั้น ๆ
2) ความผิดพลาดทางตรรกะ (logical error) เป็นความผิดพลาดที่เกิดจากการลำดับการทำงานผิดหรือป้อนสูตรคำนวณผิด ตัวอย่างเช่น ต้องการหาค่า X = X + Y แต่ป้อนสูตรเป็น X = X * Y อย่างนี้ เป็นต้น วิธีการตรวจหาความผิดพลาดแบบนี้ คือ ตรวจสอบการคำนวณผลลัพธ์ของโปรแกรมว่าตรงกับผลลัพธ์ที่คำนวณด้วยมือหรือเครื่องคิดเลขหรือไม่ ถ้าไม่ตรงกันแสดงว่าเกิดความผิดพลาดทางตรรกะขึ้น วิธีการแก้ไขก็คือ การแก้ไขสูตรให้ถูกต้อง หรือแก้ไขลำดับการทำงานให้ถูกต้อง
ดังนั้น จะเห็นได้ว่าผู้เขียนโปรแกรมจะต้องทำการทดสอบโปรแกรมและแก้ไขโปรแกรมให้สามารถทำงานได้ตามที่ต้องการ
1.1.5 การจัดทำเอกสารประกอบ และการบำรุงรักษาโปรแกรม (documentation and maintenance program)
เมื่อผู้เขียนโปรแกรมได้ทำการทดสอบโปรแกรมและแก้ไขความผิดพลาดที่เกิดขึ้นเรียบร้อยแล้ว ขั้นตอนต่อไปก็ควรจัดทำคู่มือการใช้โปรแกรม เพราะจะทำให้ผู้ใช้โปรแกรมสามารถใช้งานได้ถูกต้อง โดยคู่มือการใช้โปรแกรมที่ดีควรจัดทำในลักษณะที่แสดงการทำงานเป็นขั้นตอน ผู้ใช้โปรแกรมสามารถปฏิบัติตามได้จริง ส่วนการบำรุงรักษาโปรแกรมที่พัฒนาขึ้นก็ต้องมีคำแนะนำให้ผู้ใช้โปรแกรมปฏิบัติ ตัวอย่างเช่น การเก็บโปรแกรมต้นฉบับ ควรเก็บไว้ในกล่องที่มิดชิด ป้องกันฝุ่นได้ ไม่ควรเก็บไว้บนโต๊ะทำงาน ไม่ควรเก็บไว้ในรถยนต์เพราะอาจถูกอากาศร้อนทำให้เสียได้ นอกจากนี้ต้องมีการสำเนาโปรแกรมต้นฉบับเอาไว้ อย่างน้อย 1 ชุด แล้วนำชุดที่สำเนาไปใช้ ไม่ควรใช้โปรแกรมต้นฉบับโดยตรง ควรเก็บเอาไว้สำหรับกรณีที่โปรแกรมสำเนาเกิดปัญหาจะได้นำโปรแกรมต้นฉบับมาทำสำเนาและใช้งานได้ทันที
artsupatpong 