คำสั่งควบคุมการทำงานของโปรแกรม

คำสั่งควบคุมการทำงานของโปรแกรม

สำหรับบทนี้จะอธิบายถึงคำสั่งควบคุมการทำงานของโปรแกรม ซึ่งแบ่งกลุ่มตามลักษณะการทำงานตามข้อกำหนดมาตรฐานของสถาบัน 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 เพื่อวนการทำงานให้ผู้ใช้เติมตัวเลข เต็มบวก หรือ เต็มลบ หรือ ศูนย์ และมีการนับจำนวนตัวเลขแต่ละชนิดด้วย แล้วแสดงผลที่ได้ออกจอภาพ

การประกอบเครื่องคอมพิวเตอร์

การประกอบเครื่องคอมพิวเตอร์

อุปกรณ์คอมพิวเตอร์ที่ต้องเอามาประกอบ จากภาพ สิ่งที่ต้องมี คือ -เมนบอร์ด(แผงวงจรใหญ่ๆมีสล็อตส้มๆเหลืองๆ)พร้อมฝาหลังเคส ฝาหลังวางอยุ่ตรงหลังพัดลมCPU -CPU(ชิพสีเงินๆ ใกล้พัดลม) -พัดลมระบายความร้อนCPU(จะมาพร้อมCPU) -แรม แผงเขียวๆวางติดกัน 2 อัน ในที่นี้เป็น512*2 บัส533 -ซีดีรอมไดร์ฟ หรือ ดีวีดีไรท์เตอร์ไดร์ฟ (ขวามือ หน้ากากสีดำ ตัวเทาๆ) -ฮาร์ดดิกส์ไดร์ฟ (วางอยุ่บนดีวีดีไรท์เตอร์ไดร์ฟ) -สาย สัญญาณ SATA ตามจำนวนฮาร์ดดิกส์ ในที่นี้ มี2เส้น เพราะHDDและ DVD-RW drive ใช้สายSATA แต่ถ้าHDDหรือ ไดร์ฟDVDเป็นสายแบบ IDE ก็ต้องสายแบบIDE(ยกเว้นใช้ตัวแปลงSATA>>IDE) -น็อตสกรู น็อตทองที่ใช้ยึดรองเมนบอร์ด แผ่นแหวนรองน็อตสีแดงๆ น็อตนี้ จะได้มาเยอะพอสมควร โดยจะได้มาจากเคส -นอกภาพ คือ เคส-เพาเวอร์ซัพพลาย ถ้า เคสจำพวก Full tower มี่ยี่ห้อ เช่นraidmax หรือ cooler master/Thermaltake  มักจะไม่มีเพาเวอร์มาให้ เพราะออกแบบมาใช้กับคอมพิวเตอร์ระดับ advance ที่ใช้พลังงานสูง โดยต้องเลือกซื้อเพาเวอร์มาใช้เอง ถ้า เคสที่ซื้อ มีเพาเวอร์อยุ่แล้ว สามารถซื้อเพาเวอร์มาเปลี่ยนแทนได้ โดยเพาเวอร์เกรดต่ำ(แบบเดียวกับที่แถมเคสระดับไม่ถึงพัน)ประมาณ3-5ร้อย วัตต์ไฟที่จ่ายได้จะไม่เต็ม เช่นของdtech แบบธรรมดา ของP&A และยี่ห้ออื่นๆเช่นFRND และเกรดกลางๆ(แบบเดียวกับที่แถมเคสระดับพันต้นๆถึง2พัน)ประมาณ6-7ร้อยบาท เช่นของdeluxe แบบธรรมดา ของdtechแบบอย่างดี และระดับสูง ราคาพันว่าขึ้นไป ส่วนใหญ่จะ1500-2000+ เช่นEnemax Thermaltake Enchance Silverstone  แบบหลังเหมาะกับ system ที่ต้องการความสเถียร หรืออุปกรณ์เยอะๆเช่น HDD-กาณืดจอหลายตัว เครื่องมือที่ใช้ -ไขควงหัวแฉก คือ อันด้ามแดง  -ไขควงแบน คือ อันด้ามเขียว  -ชุดไขควงเล็ก 5 ตัว  -คีมปากจิ้งจก อันสีส้มๆ  -คีมตัด อันสีน้ำเงิน (ไม่จำเป็น แต่ถ้ามีการใช้เข็มขัดรัดสายจะดีกว่ากรรไกร-คัตเตอร์ตัด) -เข็มขัดรัดสาย ห่อขาวๆ ไม่จำเป็นต้องซื้อมาเยอะ หาซื้อจากร้านอิเล็กได้ทั่วไป  -ซิลิโคน อันนี้แบบธรรมดา หรือจะแบบดีๆก็จะแพงขึ้น เช่นMX-1 Arctic silver  ถ้าไม่OC แบบธรรมดาก็สามารถใช้งานได้ -บัตร เติมเงิน(พลาสติก) บัตรพลาสติก ที่เติมเงินเกมส์ออนไลน์ หรือโทรศัพท์ก็ได้ หรือพวกบัตรเครดิตที่ใช้ไม่ได้แล้ว เอามาปาดซิลิโคนให้บางเป็นหน้าเดียวกัน! -คัตเตอร์(ไม่ได้มีความจำเป็น เหมาะกับใช้เวลาตัดกรีดห่ออุปกรณ์คอมพิวเตอร์ที่แกะกล่องมา) การประกอบเครื่องคอมพิวเตอร์ด้วยตนเอง ปัจจุบันไม่ใช่เรื่องยากอีกต่อไป ซึ่งเราสามารถหัดประกอบด้วยตนเองได้ โดยมีขั้นตอน ดังนี้ 1. ขั้นแรกให้เตรียมอุปกรณ์ที่จำเป็นสำหรับการประกอบเครื่องคอมพิวเตอร์ เช่น ไขควงสี่แฉก กล่องสำหรับใส่น็อต คู่มือเมนบอร์ด คีมปากจิ้งจก 2. เริ่มจากการติดตั้งซีพียูก่อน โดยง้างขาล็อคของซ็อกเก็ตขึ้นมาจากนั้น นำซีพียูมาใส่ลงไปในซ็อกเก็ตโดยให้วางตำแหน่งขาที่ 1 ของซีพียูและซ็อกเก็ตให้ตรง กัน โดยสังเกตว่าที่ขาที่ 1 ของซีพียูจะทำเครื่องหมายเป็นจุดเล็กไว้ที่มุมด้านบนของ ซีพียู 3. เมื่อวางซีพียูตรงล็อคกับซ็อกเก็ตแล้ว จากนั้นให้กดขาล็อกลงไปเหมือน เดิม แล้วนำซิลิโคนมาทาตรงบริเวณคอร์ (แกน) ของซีพียู และไม่ควรทาซิลิโคนให้ หนา หากเห็นว่าหนาเกินไปให้ใช้กระดาษหรือแผ่นพลาสติกมาปาดออกเสียบ้าง 4. ติดตั้งฮีทซิงค์และพัดลมลงไปบนคอร์ของซีพียู ติดล็อกให้เรียบร้อย ในขั้นตอนนี้มีจุดที่ต้องระวังอยู่ 2 จุดคือ การติดตั้งฮีทซิงค์ของพัดลมจะต้องแนบ สนิทกับคอร์ของซีพียู อย่าพยายามกดแรงไป บางทีคอร์ของซีพียูอาจบิ่นได้ ส่วนขา สปริงที่ยึดพัดลมบางทีมันแข็งเกินไป บางคนใช้ไขควงพยามยามกดขาสปริง ให้เข้าล็อก ซึ่งอาจทำให้พลาดไปขูดเอาลายปริ้นบนเมนบอร์ดขาดทำให้เมนบอร์ด อาจเสียหายได้ 5. เสียบสายไฟของพัดลมเข้ากับขั้ว CPU FAN โดยดูจากคู่มือเมนบอร์ด 6. นำแรมมาเสียบเข้ากับซ็อกเก็ตแรมโดยให้ตรงกับร่องของซ็อกเก็ต จากนั้น จึงกดลงไปจนด้านล็อกทั้ง 2 ด้านดีดขึ้นมา (บางเมนบอร์ดตัวล็อกทั้งสองด้าน อาจไม่จำเป็นต้องดีดขึ้นมาก็ได้ให้ดูว่าเข้าล็อกกันก็พอ) 7. ขันแท่นรองน็อตเข้ากับเคส 8. นำเมนบอร์ดที่ได้ติดตั้งซีพียูและแรมวางลงไปบนเคส จากนั้นขันน็อตยึด เมนบอร์ดเข้ากับตัวเคสให้ครบทุกตัว 9. เสียบการ์ดแสดงผลลงไปในสล็อต AGP เสร็จแล้วขันน็อตยึดติดกับเคส 10. เสียบการ์ดเสียงลงไปในสล็อต PCI เสร็จแล้วขันน็อตยึดติดกับเคส 11. เสียบสายเพาเวอร์ซัพพลายเข้ากับขั้วต่อบนเมนบอร์ด โดยควรเสียบให้ ปลั๊กของสายเพาเวอร์ซัพพลายตรงล็อกกับขั้วต่อบนเมนบอร์ด 12. สอดไดรฟ์ซีดีรอมเข้ากับช่องว่างหน้าเคส แล้วขันน็อตยึดกับตัวเคส ให้แน่น 13. เสียบสาย IDE เข้ากับไดรฟ์ซีดีรอมโดยให้แถบสีแดงตรงกับขาที่ 1 หรือด้านที่ติดกับขั้วสายไฟ จากนั้นจึงเสียบสายไฟและสายสัญญาณเสียงเข้าไปด้วย 14. เสียบสาย IDE อีกด้านเข้ากับขั้วต่อ Secondary IDE บนเมนบอร์ด โดยแถบสีแดงตรงกับขาที่ 1 ของขั้วต่อด้วย 15. สอดฮาร์ดดิสก์เข้ากับช่องติดตั้ง แล้วขันน็อตยึดกับตัวเคสให้แน่น 16. เสียบสาย IDE เข้ากับฮาร์ดดิสก์โดยให้แถบสีแดงตรงกับขาที่ 1 หรือด้าน ที่ติดกับขั้วสายไฟ จากนั้นจึงเสียบสายไฟเข้าไปด้วย 17. เสียบสาย IDE อีกด้านเข้ากับขั้วต่อ Primary IDE บนเมนบอร์ด โดยแถบ สีแดงตรงกับขาที่ 1 ของขั้วต่อด้วย 18. สอดไดรฟ์ฟล็อบปี้ดิสก์เข้าไปในช่องติดตั้ง แล้วขันน็อตยึดกับตัวเคส ให้แน่น 19. เสียบสายไฟเข้ากับขั้วต่อสายไฟของฟล็อบปี้ดิสก์ ให้สังเกตสายไฟของ ฟล็อบปี้ดิสก์จะมีหัวขนาดเล็กกว่าสายไฟของซีดีรอมและฮาร์ดดิสก์ 20. เสียบสายแพขนาด 34 เส้น (เส้นเล็กกว่าสายแพของฮาร์ดดิสก์ และซีดีรอม) ให้ด้านที่มีการไขว้สายเข้ากับขั้วต่อไดรฟ์ฟล็อบปี้ดิสก์ โดยแถบสีแดง ของสายแพต้องตรงกับขาที่ 1 ของขั้วต่อด้วย หากใส่ผิดด้านไฟของไดรฟ์ ฟล็อบปี้ดิสก์จะติดตลอด วิธีแก้ไขคือให้หันสายแพกลับด้านเพราะไดรฟ์ฟล็อบปี้ดิสก์ บางยี่ห้ออาจต้องใส่สลับด้านกัน 21. เสียบสายแพอีกด้านเข้ากับขั้วต่อฟล็อบปี้ดิสก์บนเมนบอร์ด โดยให้สาย สีแดงตรงกับขาที่ 1 หรือ pin1 ของขั้วต่อด้วย 22. เสียบสายสัญญาณต่างๆ จากเคส เช่น สวิตช์เปิดปิดเครื่อง ไฟบอก สถานะเปิดเครื่อง ไฟบอกสถานะฮาร์ดดิสก ปุ่ม Reset ลำโพง ลงบนเมนบอร์ด ควรดูคู่มือเมนบอร์ดประกอบด้วย โดยต้องเสียบขั้วให้ถูกหากผิดขั้ว คอมพิวเตอร์ จะไม่ติดหรือมีไฟค้างตลอดเวลา วิธีแก้ไขคือให้เราลองสลับขั้วและเปิดเครื่องขึ้น มาใหม่ 23. เมื่อเสร็จเรียบร้อยแล้วให้เราลองสำรวจดูว่ามีน็อตหรืออุปกรณ์อื่นๆ ตกค้างอยู่บนเมนบอร์ดหรือไม่ เพราะอาจทำให้เกิดกระแสไฟลัดวงจรจนเกิดความ เสียหายต่อเมนบอร์ดและอุปกรณ์ต่างๆ บนเมนบอร์ดได้ นอกจากนี้ควรตรวจสอบ การติดตั้งทั้งหมดว่าเรียบร้อยดีแล้ว เช่น การ์ดต่างๆ หรือสายสัญญาณเสียบ แน่นหนาดีหรือยัง โดยเฉพาะฮีทซิงค์และพัดลมต้องแนบสนิทกับซีพียู พร้อมทั้งล็อก ติดกันอย่างแน่นหนา 24. เมื่อเรียบร้อยดีแล้วปิดฝาเคสและขันน็อตให้เรียบร้อย ก็เป็นอันเสร็จสิ้น

ฟังก์ชันของภาษา c

ฟังก์ชันของภาษา c
ในบทนี้จะอธิบายถึงฟังก์ชัน   ในภาษาซีซึ่งกล่าวถึงการทำงานของฟังชันก์   การสร้างฟังก์ชันและรูปแบบของฟังก์ชัน   การส่งค่าลักษณะต่าง ๆ และจะกล่าวถึงฟังก์ชันมาตรฐานของภาษาซีด้วย

การเขียนโปรแกรมภาษาในภาษาซี 
การเขียนโปรแกรมในภาษาซีนั้นสามารถเขียนได้ 2 แบบ 

แบบที่ 1 เขียนแบบโครงสร้าง 
                หรือเป็นบรรทัดไปเรื่อย ๆ หรือทั้งโปรแกรมมีเพียงหนึ่งฟังก์ชันคือ ฟังชันก์ main( ) การเขียนแบบนี้มีข้อดีคือ  เหมาะสำหรับโปรแกรมสั้น ๆ แต่เมื่อนำไปใช้กับโปรแกรมที่มีขนาดยาวถ้าในโปรแกรมมีชุดคำสั่งที่ซ้ำกัน และการตรวจสอบหาข้อผิดพลาดนั้นทำได้ยาก  เพราะจะต้องรันทั้งโปรแกรม 

แบบที่ 2 เขียนแบบฟังก์ชัน 
เป็นการเขียนโปรแกรมโดยแบ่งการทำงานของโปรแกรมออกเป็นฟังก์ชันย่อย   แต่ยังต้องมีฟังก์ชัน main( ) อยู่เหมือนเดิม  แต่ฟังก์ชัน main( ) นี้จะไปเรียกฟังก์ชันอื่นขึ้นมาทำงานต่อไป   การเขียนแบบนี้มีข้อดีคือ การทำงานของโปรแกรมนั้นตรวจสอบได้ง่าย  เพราะสามารถรันเฉพาะฟังก์ชันได้   และทำให้ตัวโปรแกรมนั้นสั้นลงในกรณีที่ชุดคำสั่งที่เหมือนกัน   ซึ่งโปรแกรมเมอร์เกือบทั้งหมดนิยมเขียนในลักษณะนี้ 

การเขียนโปรแกรมแบบฟังก์ชัน 
การเขียนโปรแกรมแบบฟังก์ชันมีขั้นตอนดังนี้ 
1. ประกาศฟังก์ชันที่ต้องการไว้ในส่วนแรกของโปรแกรม 
2. เรียกใช้ฟังก์ชันที่ประกาศไว้ 
3. กำหนดหรือสร้างรายละเอียดของฟังก์ชันนั้น

โปรแกรม 5 – 1 แสดงขั้นตอน 3 ขั้นตอนของการสร้างฟังก์ชัน

           จากตัวอย่างข้างต้นจะเห็นได้ว่า   สิ่งที่จำเป็นสำหรับเรื่องฟังก์ชันก็คือ   ชื่อของฟังก์ชันเพราะถ้าเรียกใช้  หรือประกาศชื่อฟังก์ชันไว้ไม่ตรงกัน  โปรแกรมที่เขียนขึ้นก็จะเกิด Error  ขึ้นมาได้   ฉะนั้นจะต้องรู้ว่าโปรแกรมที่เขียนนั้นมีฟังก์ชันอะไรบ้าง

กิจกรรมนับคาบเรียน 

คำสั่ง  ให้นักเรียนเขียนโปรแกรมลอกเลียนแบบตัวอย่างโปรแกรม 5-1  โดยกำหนดให้  แสดงผล เป็น  Hello  C

กดคลิกเื่พื่อส่งโปรแกรม

กดคลิกเื่พื่อส่งผลลัพธ์ที่ได้จากโปรแกรม

---

รายละเอียดการติดตามการเรียน

ให้นักเรียน  บันทึกกิจกรรมที่ส่ง  กดที่นี่

ผู้ปกครองติดตามการเรียนของนักเรียน  กดที่นี่

---

การสร้างฟังก์ชัน
 

รูปที่ 5 – 2 ส่วนประกอบต่าง ๆ ของฟังก์ชัน

  

                       ส่วนหัวของฟังก์ชัน  ( Function Header )ประกอบ ด้วย 3 ส่วนหลัก  คือ  ชนิดข้อมูลของค่าที่ส่งกลับ  (Return Type )ชื่อฟังก์ชัน ( Function name )   และรายชื่อพารามิเตอร์ซึ่งจะมีการบอกชนิดข้อมูล  เหมือนการประกาศตัวแปร  และสามารถมีหลายตัวได้โดยเครื่องหมาย , คั้นระหว่างแต่ละพารามิเตอร์
ถ้าไม่ได้ใช้ Return type ภาษาซี จะถือว่ามีค่าที่ส่งกลับเป็นชนิดข้อมูลแบบ Integer  แล้ว ในส่วนรายละเอียดของฟังก์ชันจะต้องมีคำสั่ง Return  ด้วนในบรรทัดที่ต้องการออกจากฟังก์ชัน  ถ้าไม่ต้องการให้ฟังก์ชันนั้นมีการส่งค่ากลับ ให้ใส่ Return Type เป็น Void และไม่ต้องใส่คำสั่ง Return
และในส่วนของรายชื่อพารามิเตอร์   ถ้าไม่ต้องการส่งค่ากลับก็ไม่ต้องใส่ก็ได้ หรือใส่เป็น Void ไว้
ส่วนรายละเอียดของฟังก์ชัน ประกอบด้วย  การประกาศตัวแปรแบบ Local และ  ชุดคำสั่งต่าง ๆ ของฟังก์ชันนั้น   เมื่อต้องการจบฟังก์ชัน  ถ้ามีการใส่ Return Type  ไว้ก็ให้ส่งค่ากลับตามชนิดของ  Return Type  ที่ใส่ เช่น
return 0; แต่ถ้าไม่มีการส่งค่ากลับใส่  ก็ไม่จำเป็นต้องมีคำสั่ง return  หรือให้ใส่คำสั่งดังนี้ return ;

               

รูปที่ 5 – 3 แสดงตัวอย่างของฟังก์ชัน

รูปแบบของฟังก์ชัน
รูปแบบของฟังก์ชันของภาษา ซี มีอยู่ 4 รูปแบบ 

แบบที่ 1 ฟังก์ชันแบบไม่มีการส่งค่ากลับ  และไม่มีพารามิเตอร์   เป็นฟังก์ชันที่ไม่มีการส่งค่ากลับไปให้กับฟังก์ชันที่เรียกมา  และไม่มีการส่งค่าจากฟังก์ชันที่เรียกมาให้ด้วย
แบบที่ 2 ฟังก์ชันแบบไม่มีการส่งค่ากลับ และพารามิเตอร์  เป็นฟังก์ชันที่จะไม่มีการส่งค่ากลับไปให้ฟังก์ชันที่เรียกขึ้นมา   แต่มีการส่งค่าจากฟังก์ชันที่เรียกมาให้ด้วย
แบบที่ 3 ฟังก์ชันแบบมีการส่งค่ากลับ  และไม่มีพารามิเตอร์  เป็นฟังก์ชันที่จะมีการส่งค่ากลับไปให้ฟังก์ชันที่เรียกมา   แต่ไม่มีการส่งค่าจากฟังก์ชันที่เรียกมาให้ด้วย
แบบที่ 4 ฟังก์ชันแบบมีการส่งค่ากลับ  และมีพารามิเตอร์  เป็นฟังก์ชันที่จะมีการส่งค่ากลับไปให้กับฟังก์ชันที่เรียกมา  แต่มีการส่งค่าจากฟังก์ชันที่เรียกมาให้ด้วย
โปรแกรม 5- 2 ตัวอย่างฟังก์ชันแบบไม่มีการส่งค่ากลับ   และไม่มีพารามิเตอร์
การประกาศฟังก์ชั่น (Prototype Declarations)
การประกาศฟังก์ชั่นนั้น  เป็นสิ่งที่จำเป็นต้องทำเสมอเมื่อจะสร้างฟังก์ชั่น  การประกาศฟังก์ชั่นนั้นจะประกาศอยู่ตรงส่วนบนสุดของโปรแกรม  หรือก่อนส่วนการประกาศตัวแปรแบบ Global ดังที่แสดงในตัวอย่างที่ 5-1 ซึ่งเมื่อสังเกตแล้วจะพบว่าการประกาศฟังก์ชั่นก็คือ  การตัดเอาเฉพาะส่วนหัวของฟังก์ชั่นไป  แล้วต่อฐานด้วยเครื่องหมาย ; นั่นเอง

การเรียกฟังก์ชั่น (Function Call)
การเรียกใช้ฟังก์ชั่นนั้น  จะต้องรู้ก่อนว่าฟังชั่นที่จะเรียกใช้มีรูปแบบเป็นอย่างไร  อาทิเช่น  มีการส่งค่ากลับหรือไม่  หรือต้องมีการส่งค่าพารามิเตอร์ไปให้ฟังก์ชันที่จะเรียกใช้หรือไม่เพื่อให้ การใช้ฟังก์ชันนั้นถูกต้องและไม่มีข้อผิดพลาด  ซึ่งการเรียกใช้ฟังก์ชันสามารถดูได้จากตัวอย่างที่ 5-2 ถึง 5-5 ดังรูปที่ 5-4 แสดงตัวอย่างการเรียกใช้ฟังก์ชันแบบต่างๆที่สามารถทำได้ 

test(a,7);
test(6,b);
test(a+6,b);
test(test(a,b),b);

   รูปที่ 5-4 แสดงตัวอย่างการเรียกใช้ฟังก์ชันแบบต่างๆ

ตัวอย่างโปรแกรม
โปรแกรม 5-6 โปรแกรมแสดงเลขหลักแรก

กิจกรรมนับคาบเรียน 

คำสั่ง  ให้นักเรียนเขียนโปรแกรมลอกเลียนแบบตัวอย่างโปรแกรม 5-6  โดยกำหนดให้  แสดงผล คำตอบ  ส่งมา

กดคลิกเื่พื่อส่งโปรแกรม

กดคลิกเื่พื่อส่งผลลัพธ์ที่ได้จากโปรแกรม

---

รายละเอียดการติดตามการเรียน

ให้นักเรียน  บันทึกกิจกรรมที่ส่ง  กดที่นี่

ผู้ปกครองติดตามการเรียนของนักเรียน  กดที่นี่

---

การส่งค่าผ่านพารามิเตอร์ ในภาษา C นั้นจะมีการส่งค่าผ่านพารามิเตอร์  หรือ  Parameter Passing ซึ่งสามารถแบ่งได้เป็น  3 ประเภทใหญ่ๆ  ดังนี้

การส่งค่าแบบกำหนดค่า (Pass by Value)
จากตัวอย่างที่ได้แสดงมาข้างต้นจะเป็นการส่งค่าในแบบกำหนดค่าทังหมด  ซึ่งเมื่อใดที่การส่งค่า  จะทำการคัดลอกข้อมูลไปให้กับพารามิเตอร์ในฟังก์ชันที่ถูกเรียก  การส่งค่าแบบนี้จะไม่ทำให้ค่าเดิมถูกเปลี่ยนแปลง ดังรูป 5-5 แสดงการส่งค่าแบบกำหนดค่า

การส่งค่าแบบอ้างอิง (Pass by Reference)
ในบางกรณี  จำเป็นที่จะต้องใช้การส่งค่าแบบอ้างอิง  ซึ่งการส่งค่าแบบนี้จะทำการเชื่อมระหว่าง  ตัวแปรที่ประกาศในฟังก์ชันที่เรียกกับพารามิเตอร์ในฟังก์ชันที่ถูกเรียกมี การเปลี่ยนค่า  ก็จะทำให้ค่าในตัวแปรของฟังก์ชันที่เรียกเปลี่ยนตามไปด้วย

การส่งค่าแบบอ้างที่อยู่(Pass by Address)
การส่งค่าแบบนี้จะใช้พอยเตอร์ซึ่งจะขอยกไปกล่าวในบทที่8

ฟังก์ชันมาตรฐาน
ในภาษา C ได้จัดเตรียมฟังก์ชันมาตรฐานต่างๆเอาไว้ให้ใช้มากมาย  ฟังก์ชันมาตรฐานต่างๆ จะอยู่ในStandard Library Files  ที่มีนามสกุลเป็น.h ถ้าต้องใช้ฟังก์ชันมาตรฐานเหล่านั้นจะต้องทราบก่อนว่าฟังก์ชันนั้นอยู่ใน Standard Library Files อันไหน แล้วนำเอา Standard Library Files นั้นเข้ามาโดยใช้คำสั่ง include
ยกตัวอย่างฟังก์ชันที่ใช้บ่อยๆ คือ ฟังก์ชัน scanf() , printf() ซึ่งถ้าจะใช้ฟังก์ชันทั้ง 2 นี้จะต้องนำเข้า Standard Library Files ที่ชื่อ stdio.h ก่อนจึงจะสามารถใช้ได้

ฟังก์ชันมาตรฐานทางคณิตศาสตร์ 
ถ้าต้องการใช้ฟังก์ชันมาตรฐานทางคณิตศาสตร์จะต้องนำเข้า  Standard Library Files 2ไฟล์ คือ math.h และ stdlib.h

          abs/fabs/labs ทั้ง3ฟังก์ชัน จะส่งค่ากลับเป็นค่า Absolute ของตัวเลขที่ส่งไปให้  ค่าAbsolute คือ ค่าทางบวกของค่านั้น สำหรับ abs ต้องมีการส่งพารามิเตอร์ที่มีชนิดข้อมูลเป็นตัวเลขจำนวนเต็มหรือ Integer สำหรับ labs ต้องมีการส่งพารามิเตอร์ที่มีชนิดข้อมูลเป็นตัวเลขที่เป็นทศนิยมหรือ Float-Point การประกาศฟังก์ชันของทั้ง 3 ฟังก์ชันเป็นดังนี้
int abs (Int number);
long labs(long number);
double fabs(double number);

ตัวอย่าง
abs(3)        ส่งค่ากลับเป็น 3
fabs(-3.4)   ส่งค่ากลับเป็น 3.4

ceil ฟังก์ชัน ceil หรือ ceiling เป็นฟังก์ชันที่จะหาค่าจำนวนเต็มที่มากกว่าหรือเท่ากับ ค่าที่ส่งไปให้ ตัวอย่างเช่น  หาค่า ceiling ของ 3.000001 จะเป็น 4.0 ถ้าพิจารณาแล้ว ผลของฟังก์ชัน ceil คือ ค่าตัวเลขจำนวนเต็มที่อยู่ทางด้านขวามือของค่าที่ส่งไปให้ ดังแสดงในรูปที่ 5-6

การประกาศฟังก์ชันของ ceil จะเป็นดังนี้
Double ceil (double number);
ตัวอย่าง
ceil(-1.9)              ส่งค่ากลับเป็น-1.0
ceil(1.1)               ส่งค่ากลับเป็น  2.0

floor ฟังก์ชัน floor เป็นฟังก์ชันที่จะหาค่าจำนวนเต็มที่น้อยกว่าหรือเท่ากับค่าที่ส่งไปให้ ตัวอย่างเช่น หาค่า floor ของ 3.99999 จะเป็น 3.0 ถ้าพิจารณาแล้ว ผลของฟังก์ชัน floor คือ ค่าตัวเลขจำนวนเต็มที่อยู่ทางด้านซ้ายมือของค่าที่ส่งไปให้  ดังแสดงในรูปที่ 4-6 โดยมีการประกาศฟังก์ชันเป็นดังนี้

                double floor(double number);
ตัวอย่าง                floor(-1.1)            ส่งค่ากลับเป็น -2.0
                floor(1.9)             ส่งค่ากลับเป็น 1.0
pow ฟังก์ชัน pow เป็นฟังก์ชันที่หาค่า x ยกกำลังด้วย y หรือ xy ซึ่งมีการประกาศฟังก์ชันดังนี้

                double pow(double x,double y);
ตัวอย่าง 
                pow(3.0,4.0)       ส่งค่ากลับเป็น 81.0
                pow(3.4,2.3)       ส่งค่ากลับเป็น 16.687893
sqrt ฟังก์ชัน sqrt เป็นฟังก์ชันที่หาค่ารากที่สองของค่าที่ส่งไปให้  ซึ่งมีการประกาศฟังก์ชันเป็นดังนี้ double sqrt(double number);

ตัวแปรชุดและสตริง

ตัวแปรชุดและสตริง

ตัวแปรชุดและสตริง

ในบทที่ผ่านมาหลายบทก่อนหน้านี้ได้พูดถึงตัวแปรชนิดต่าง ๆ หลายชนิด สำหรับเนื้อหาในบทนี้ จะได้เรียนรู้เกี่ยวกับตัวแปรอีกชนิดหนึ่งนั่นคือตัวแปรชุด (arrays) และเนื้อหาเกี่ยวกับสตริง (string) ซึ่งเป็นพื้นฐานที่สำคัญในการจัดเก็บข้อมูลและโครงสร้างของข้อมูลโดยเฉพาะอย่างยิ่งตัวแปรชุดมีประโยชน์หลายประการดังนี้
1) ช่วยลดการตั้งชื่อซ้ำ ๆ กัน เช่น ต้องการเก็บค่าตัวเลขจำนวนเต็ม 100 ตัว ถ้าไม่มีการใช้ตัวแปรชุด เราจะต้องประกาศตัวแปรถึง 100 ตัว ดังนี้
int k1, k2, k3, …, k100; /* ประกาศตัวแปร k1, k2, k3, …, k100 จำนวน 100 ตัว */ แต่ถ้าเราใช้ตัวแปรชุดมาช่วยในการเก็บข้อมูลตัวเลขชุดนี้ เราสามารถเก็บตัวเลข 100 ตัวนี้ไว้ในชื่อเดียวกัน แต่มีตัวเลข subscript คอยกำกับเพื่อบ่งบอกถึงลำดับที่ของข้อมูลในตัวแปรได้
int k[100]; /* ประกาศตัวแปรชุด 1 ตัว คือชื่อตัวแปร k */
2) ช่วยในการจัดเก็บข้อมูลแบบตาราง (table) โดยสามารถใช้ตัวแปรชุด 2 มิติ มาเก็บข้อมูลได้
3) ช่วยในการเขียนโปรแกรมมีประสิทธิภาพมากขึ้น เนื่องจากในโปรแกรมที่มีการใช้ตัวแปรชุดจะมีตัวแปรน้อยลง ช่วยในการจัดเรียงข้อมูล และค้นหาข้อมูลได้สะดวกและรวดเร็ว
5.1 ตัวแปรชุด (arrays variables)
ตัวแปรชุด คือ ตัวแปรชนิดหนึ่งที่ใช้ชื่อเพียงชื่อเดียวแต่มีตัวเลขแสดงตำแหน่งกำกับไว้ (subscript) เพื่อเป็นการบอกว่าเป็นสมาชิกของตัวแปรชุดตัวที่เท่าไหร
5.1.1 ประเภทของตัวแปรชุด มีดังนี้
1) ตัวแปรชุด 1 มิติ (one dimension arrays หรือ single dimension arrays) ตัวแปรชุด 1 มิติ คือ ตัวแปรชุดที่มีตัวเลขกำกับ (subscript) เพียง 1 ตัว เช่น a[20], b[100], name[30] และ salary[20] เป็นต้น
2) ตัวแปรชุดหลายมิติ (multi-dimension arrays) ตัวแปรชุดหลายมิติ คือ ตัวแปรชุดที่มีตัวเลขกำกับ (subscript) ตั้งแต่ 2 ตัวขึ้นไป โดยมากจะสนใจศึกษาตัวแปรชุดที่มีตัวเลขกำกับ 2 ตัว และ 3 ตัว ดังนี้
ตัวแปรชุด 2 มิติ (two dimension arrays) คือ ตัวแปรชุดที่มีตัวเลขกำกับ (subscript) เพียง 2 ตัว เช่น a[2][4], b[3][4], name[5][30] เป็นต้น
ตัวแปรชุด 3 มิติ (three dimension arrays) คือ ตัวแปรชุดที่มีตัวเลขกำกับ (subscript) เพียง 3 ตัว เช่น a[2][3][4], b[3][4][5] เป็นต้น
5.1.2 การประกาศตัวแปรชุด (declaration of arrays) สามารถทำได้ดังนี้
1) การประกาศตัวแปรชุด 1 มิติ (declaration of one dimension arrays)

โดยที่

type คือ ชนิดของตัวแปรชุด เช่น int, float, char, double เป็นต้น
arrayname คือ ชื่อตัวแปรชุด ตั้งขึ้นตามหลักการตั้งชื่อตัวแปร
size คือ ขนาดของตัวแปรชุดเป็นตัวเลขจำนวนเต็ม
ตัวอย่างการประกาศตัวแปรชุด 1 มิติ
ตัวอย่างที่ 5.1 int s[20]; ภายในหน่วยความจำจะมีการจองเนื้อที่ไว้ดังนี้

การจองเนื้อที่ใช้ช่องละ 2 bytes 20 ช่อง รวมกันทั้งหมดใช้เนื้อที่ 40 bytes

ตัวอย่างที่ 5.2 char p[20]; ภายในหน่วยความจำจะมีการจองเนื้อที่ไว้ดังนี้

การจองเนื้อที่ใช้ช่องละ 1 bytes 20 ช่อง รวมกันทั้งหมดใช้เนื้อที่ 20 bytes
ตัวอย่างที่ 5.3 float t[20]; ภายในหน่วยความจำจะมีการจองเนื้อที่ไว้ดังนี้

การจองเนื้อที่ใช้ช่องละ 4 bytes 20 ช่อง รวมกันทั้งหมดใช้เนื้อที่ 80 bytes

2) การประกาศตัวแปรชุด 2 มิติ (declaration of two dimension arrays) 

โดยที่

type คือ ชนิดของตัวแปรชุด เช่น int, float, char, double เป็นต้น
arrayname คือ ชื่อตัวแปรชุด ตั้งขึ้นตามหลักการตั้งชื่อตัวแปร
n คือ ตัวเลขที่ใช้แสดงตำแหน่งแถว (row) มีค่าตั้งแต่ 0, 1, 2, …, n-1
m คือ ตัวเลขที่ใช้แสดงตำแหน่งคอลัมน์ (column) มีค่าตั้งแต่ 0, 1, 2, …, m-1

ตัวอย่างการประกาศตัวแปรชุด 2 มิติ
ตัวอย่างที่ 5.4 int r[3][2]; ภายในหน่วยความจำจะมีการจองเนื้อที่ไว้ดังนี้

การจองเนื้อที่ของตัวแปรชุด 2 มิติ จะมีลักษณะเป็นตาราง (table) มีจำนวนแถว n = 0, 1, 2 และมีจำนวนคอลัมน์ m = 0, 1 โดยที่ในตารางจะมีลักษณะเป็นช่อง ๆ ซึ่งแต่ละช่องก็คือพื้นที่ของสมาชิกแต่ละตัว โดยใช้เนื้อที่ช่องละ 2 bytes มีสมาชิกทั้งหมด 6 ตัว ดังนั้นใช้เนื้อที่ทั้งหมด 12 bytes
วิธีการหาจำนวนสมาชิกทั้งหมดของตัวแปรชุด 1 มิติ และ 2 มิติ
การหาจำนวนสมาชิกทั้งหมดของตัวแปรชุด สามารถคำนวณได้จากสูตรดังนี้
กรณีตัวแปรชุด 1 มิติ
จำนวนสมาชิกทั้งหมดของตัวแปรชุด = ขนาดของตัวแปรชุด (size)
กรณีตัวแปรชุด 2 มิติ
จำนวนสมาชิกทั้งหมดของตัวแปรชุด = n*m
จากตัวอย่าง int r[3] [2]; จะได้ว่า n = 3, m = 2 ดังนั้น จำนวนสมาชิกของตัวแปรชุด = 3*2 = 6 แสดงว่าตัวแปรชุดนี้มีสมาชิกดังนี้ r[0][0], r[0][1], r[n-1][m-1] รวมทั้งหมด 6 สมาชิก
ตัวอย่างที่ 5.5 float X[5] [4]; ภายในหน่วยความจำจะมีการจองเนื้อที่ไว้ดังนี้


การจองเนื้อที่จะมีลักษณะเป็นตาราง (table) มีจำนวนแถว n = 0, 1, 2, 3, 4 และมีจำนวนคอลัมน์ m = 0, 1, 2, 3 โดยที่ในตารางใช้เนื้อที่ช่องละ 4 bytes มีจำนวนทั้งหมด 20 ตัว ดังนั้นใช้เนื้อทั้งหมด 80 bytes

3) การประกาศตัวแปรชุด 3 มิติ (declaration of three dimension arrays)
type arrayname [n] [m] [p];

โดยที่

type คือ ชนิดของตัวแปรชุด เช่น int, float, char, double เป็นต้น
arrayname คือ ชื่อตัวแปรชุดตั้งขึ้นตามหลักการตั้งชื่อตัวแปร
n คือ ตัวเลขกำกับตัวที่ 1 มีค่าตั้งแต่ 0, 1, 2, …., n-1
m คือ ตัวเลขกำกับตัวที่ 2 มีค่าตั้งแต่ 0, 1, 2, …., m-1 p คือ ตัวเลขกำกับตัวที่ 3 มีค่าตั้งแต่ 0, 1, 2, …., p-1

วิธีการหาจำนวนสมาชิกทั้งหมดในตัวแปรชุด 3 มิติ หาได้จากสูตรดังนี้
จำนวนสมาชิกทั้งหมดของตัวแปรชุด = n*m*p

ตัวอย่างการประกาศตัวแปรชุด 3 มิติ float a[2][2][3]; ดังนั้น n = 2 , m = 2, p = 3 จะได้ว่าจำนวนสมาชิกทั้งหมดของตัวแปรชุด = 2*2*3 = 12 ตัว

ดังนั้นเราสามารถเขียนสมาชิกทั้งหมดของตัวแปรชุดนี้ได้ดังตาราง
Column 0 Column 1
ตัวที่ 1 ตัวที่ 2 ตัวที่ 3 ตัวที่ 1 ตัวที่ 2 ตัวที่ 3
Row 0 a[0][0][0] a[0][0][1] a[0][0][2] a[0][1][0] a[0][1][1] a[0][1][2]
Row 1 a[1][0][0] a[1][0][1] a[1][0][2] a[1][1][0] a[1][1][1] a[1][1][2]

โดยที่สมาชิกแต่ละตัวใช้เนื้อที่ตัวละ 4 bytes จำนวนสมาชิกทั้งหมดมี 12 ตัว ดังนั้นใช้เนื้อที่ทั้งหมดคือ 4*12 = 48 bytes
5.1.3 การกำหนดค่าเริ่มต้นให้กับตัวแปรชุด (initializing arrays)
1) การกำหนดค่าตัวเลขให้กับตัวแปรชุด
รูปแบบที่ 1 (กรณีตัวแปรชุด 1 มิติ)
type arrayname[size] = { value list };

รูปแบบที่ 2 (กรณีตัวแปรชุด 2 มิติ)
type arrayname[n][m] = { value list };

โดยที่

value list คือ ค่าคงที่ชนิดตัวเลขที่ต้องการกำหนดให้ตัวแปรชุด ถ้ามีหลายค่าให้ใช้เครื่องหมาย , (comma) คั่นระหว่างค่าคงที่แต่ละค่า
โดยค่าคงที่ทั้งหมดจะต้องอยู่ภายใต้เครื่องหมาย { }
ตัวอย่าง 5.6 int a[10] = {10, 20, 30, 40,50, 60, 70, 80, 90, 100};
ภายในหน่วยความจำจะเก็บตัวแปรชุดดังนี้

ตัวอย่างที่ 5.7 float p[5][3] = {

3.0, 4.5, 5.5,
4.6, 5.5, 6.5,
5.0, 6.2, 7.0,
6.3, 6.8, 7.4,
7.5, 8.0, 9.0
};

ภายในหน่วยความจำจะเก็บตัวแปรชุดเป็นลักษณะตาราง (table) ดังนี้

โดยที่สมาชิกแต่ละตัวใช้เนื้อที่ 4 bytes ดังนั้นใช้เนื้อที่ทั้งหมด = 4*15 = 60 bytes

2) การกำหนดค่าคงที่ชนิดสตริงให้กับตัวแปรสตริง
รูปแบบที่ 1 (กรณีตัวแปรชุด 1 มิติ)
char arrayname[size] = “string constant”;


รูปแบบที่ 2 (กรณีตัวแปรชุด 2 มิติ)
char arrayname[n][m] = {“string constant”};
โดยที่
string constants คือ ค่าคงที่ชนิดสตริงที่ต้องการกำหนดให้ตัวแปรชุด ถ้ามีหลายค่าจะต้องใช้เครื่องหมาย , (comma) คั่นระหว่างค่าคงที่แต่ละค่า
ตัวอย่างที่ 5.8 char s[12] = “ASIAN GAME” ;
ภายในหน่วยความจำจะเก็บข้อมูลตัวแปรชุดมีลักษณะดังนี้

null character

ตัวอย่างที่ 5.9 char province[3][13] = {
“NAKHONPANOM” ,
“SAKON NAKHON” ,
“MOOKDAHAN” } ;
ภายในหน่วยความจำจะเก็บข้อมูลมีลักษณะดังนี้
ทั้งหมดใช้เนื้อที่ 3 x 13 = 39 bytes
การอ้างถึงสมาชิกในตัวแปรชุด 2 มิติ

เช่น

province [0] คือ สมาชิกแถวที่ 1 ทั้งแถว นั่นคือข้อมูล NAKHONPANOM
province [1] คือ สมาชิกแถวที่ 2 ทั้งแถว นั่นคือข้อมูล SAKON NAKHON province [2] คือ สมาชิกแถวที่ 3 ทั้งแถว นั่นคือข้อมูล MOOKDAHAN
province [0][0] คือ สมาชิกของ province [0] ตัวที่ 1 คือตัวอักษร N
province [1][2] คือ สมาชิกของ province [1] ตัวที่ 3 คือตัวอักษร K
5.1.4 การนำข้อมูลเข้าไปเก็บและการแสดงผลลัพธ์ของข้อมูลในตัวแปรชุด
โดยปกติเราจะใช้คำสั่ง for หรือ while หรือ do while คำสั่งใดคำสั่งหนึ่งมาช่วยในการนำข้อมูลเข้าเก็บและแสดงผลลัพธ์ข้อมูลในตัวแปรชุด ส่วนมากนิยมใช้คำสั่ง for มากกว่าคำสั่งอื่นทั้งนี้เนื่องจากตัวแปรชุดนั้นเราสามารถทราบขนาดที่แน่นอนได้ ทำให้กำหนดจำนวนรอบการทำงานได้
เพื่อความเข้าใจเกี่ยวกับการนำข้อมูลเข้าไปเก็บและการแสดงผลลัพธ์ของตัวแปรชุดมากยิ่งขึ้น ให้ศึกษาโปรแกรมตัวอย่างที่ 5.1, 5.2, 5.3 และ 5.4 ดังต่อไปนี้

โปรแกรมตัวอย่างที่ 5.1 แสดงการใช้ตัวแปรชุด 1 มิติ ชื่อ scores เก็บคะแนนนักเรียน


/* array1.C */
#include<stdio.h> /* บรรทัดที่ 1 */
#include<conio.h> /* บรรทัดที่ 2 */
/* Record student's scores. */ /* บรรทัดที่ 3 */
main() /* บรรทัดที่ 4 */
{ /* บรรทัดที่ 5 */
int index, scores[5]; /* บรรทัดที่ 6 */
scores[0] = 59; /* บรรทัดที่ 7 */
scores[1] = 67; /* บรรทัดที่ 8 */
scores[2] = 85; /* บรรทัดที่ 9 */
scores[3] = 92; /* บรรทัดที่ 10 */
scores[4] = 74; /* บรรทัดที่ 11 */
clrscr(); /* บรรทัดที่ 12 */
for (index = 0; index < 5; index++) /* บรรทัดที่ 13 */
printf("Student's score: %d\n", scores[index]); /* end for */ /* บรรทัดที่ 14 */
getch(); /* บรรทัดที่ 15 */
return(0); /* บรรทัดที่ 16 */
} /* บรรทัดที่ 17 */


ผลลัพธ์ที่ได้จากโปรแกรม

คำอธิบายโปรแกรม
จากโปรแกรมตัวอย่างที่ 5.1 สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ ได้ดังนี้

บรรทัดที่ 6 ประกาศตัวแปร index เป็นชนิดจำนวนเต็ม และ scores เป็นตัวแปรชุด 1 มิติ ชนิดจำนวนเต็มมีสมาชิก 5 ตัว
บรรทัดที่ 7 ถึง 11 กำหนค่าจำนวนเต็มให้กับตัวแปรชุด scores[0] ถึง scores[4]
บรรทัดที่ 13 คำสั่ง for ทำหน้าที่วนรอบทำงานซ้ำ 5 ครั้ง เพื่อช่วยพิมพ์คะแนนนักเรียนที่เก็บไว้ในตัวแปรชุด scores[0] ถึง scores[4]
บรรทัดที่ 14 และ 15 ฟังก์ชัน printf( ) เพื่อแสดงคะแนนของนักเรียนแต่ละคนออกที่จอภาพซึ่งเก็บไว้ในตัวแปรชุด scores[0] ถึง scores[4] หลังจากนั้นจะหยุดรอรับค่าใด ๆ จากคีย์บอร์ด ซึ่งถ้ากด enter ก็จะกลับสู่โปรแกรม
บรรทัดที่ 16 ส่งค่า 0 (ศูนย์) กลับให้กับฟังก์ชัน main( )
ข้อสังเกต ฟังก์ชัน main( ) ของโปรแกรมตัวอย่างที่ 5.1 เป็นฟังก์ชันที่ต้องการให้ส่งค่ากลับ ในการเขียนโปรแกรมจะต้องมีการใช้ฟังก์ชัน return( ) ซึ่งถ้าไม่ใช้เวลาที่เรา compile โปรแกรม จะมีคำเตือนให้เราทราบทุกครั้ง แต่โปรแกรมก็สามารถ run ได้
โปรแกรมตัวอย่างที่ 5.2 แสดงการใช้ตัวแปรชุด 1 มิติ สำหรับเก็บข้อมูลและนำข้อมูลในตัวแปรชุดมาคำนวณค่า พร้อมทั้งแสดงผลลัพธ์ที่ได้ออกจอภาพ


/* array2.c */
#include<stdio.h> /* บรรทัดที่ 1 */
#include<conio.h> /* บรรทัดที่ 2 */
#include<stdlib.h> /* บรรทัดที่ 3 */
void main(void) /* บรรทัดที่ 4 */
{ float num[100] ; /* บรรทัดที่ 5 */
float sum= 0 , average ; /* บรรทัดที่ 6 */
int i, n ; char numstr[20]; /* บรรทัดที่ 7 */
clrscr(); /* บรรทัดที่ 8 */
printf("Enter Total of number(n<100) : "); /* บรรทัดที่ 9 */
n = atoi(gets(numstr)); /* บรรทัดที่ 10 */
/* ===== Input Data ===== */ /* บรรทัดที่ 11*/
for( i=0; i<n; i++) { /* บรรทัดที่ 12 */
printf("\nEnter NUMBER #%d : ",i+1); /* บรรทัดที่ 13 */
num[i] = atof(gets(numstr)); /* บรรทัดที่ 14 */
sum=sum+num[i]; /* บรรทัดที่ 15 */
printf("\n"); /* บรรทัดที่ 16 */
} /* end for */ /* บรรทัดที่ 17 */
/* ===== Calulate MEAN ===== */ /* บรรทัดที่ 18 */
average = sum/n ; /* บรรทัดที่ 19 */
printf("N =%d\t Sum =%10.2f\n",n,sum); /* บรรทัดที่ 20 */
printf("Average = %10.2f\n",average); /* บรรทัดที่ 21 */
getch(); /* บรรทัดที่ 22 */
} /* end main */ /* บรรทัดที่ 23 */


ผลลัพธ์ที่ได้จากโปรแกรม

คำอธิบายโปรแกรม
จากโปรแกรมตัวอย่างที่ 5.2 สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ ได้ดังน
ี้
บรรทัดที่ 3 คำสั่ง #include <stdlib.h> ให้การสนับสนุนฟังก์ชัน atoi( ) และฟังก์ชัน atof( ) สำหรับโปรแกรมนี้ ในบรรทัดที่ 10 และ 14 ตามลำดับ
บรรทัดที่ 5 ประกาศตัวแปร num เป็นตัวแปรชุด 1 มิติ ชนิด float มีสมาชิก 100 ตัว
บรรทัดที่ 7 ประกาศตัวแปร numstr เป็นตัวแปรชุด 1 ติ ชนิด char มีสมาชิก 20 ตัว
บรรทัดที่ 10 ฟังก์ชัน atoi( ) ใช้เปลี่ยน string เป็นตัวเลขจำนวนเต็ม จากฟังก์ชัน gets( ) รับตัวอักขระมาเก็บไว้ในตัวแปร numstr แล้วเปลี่ยนค่า string ของตัวแปร numstr ไปเก็บไว้ในตัวแปร n โดยใช้ฟังก์ชัน atoi( )
บรรทัดที่ 12 คำสั่ง for ช่วยในการเก็บข้อมูลไว้ในตัวแปรชุด num ซึ่งมีจำนวนรอบของการทำงานเท่ากับจำนวนสมาชิกของตัวแปรชุด คือ n รอบ
บรรทัดที่ 14 ฟังก์ชัน atof( ) ใช้เปลี่ยน string เป็นตัวเลขทศนิยม ซึ่งมีการทำงานคล้ายกับฟังก์ชัน atoi( ) ในบรรทัดที่ 10
บรรทัดที่ 15 คำสั่ง sum = sum + num[i]; เป็นการบวกสะสมค่าตัวแปรชุด
บรรทัดที่ 18 ถึง 21 คำสั่ง average = sum/n; เป็นการคำนวณค่าเฉลี่ยของตัวแปรชุด แล้วแสดงผลค่าตัวแปร n ตัวแปร sum และตัวแปร average ออกจอภาพ
บรรทัดที่ 22 หยุดรอรับค่าใด ๆ จากคีย์บอร์ด ซึ่งถ้าเรากด enter ก็จะกลับสู่โปรแกรม

โปรแกรมตัวอย่างที่ 5.3 แสดงการใช้ตัวแปรชุด 2 มิติ สำหรับเก็บคะแนนและคำนวณค่าเฉลี่ยของคะแนนในแต่ละชุดแสดงผลออกจอภาพ

ความรู้พื้นฐานการเขียนโปรแกรม

ความรู้พื้นฐานการเขียนโปรแกรม

ความู้พื้นฐานการเขียนโปรแกรม           

เนื้อหาในบทนี้จะกล่าวถึงขั้นตอนวิธีการทางคอมพิวเตอร์ (computer  algorithms)  เพื่อเป็นการให้ความรู้พื้นฐานก่อนการเขียนโปรแกรมคอมพิวเตอร์  รวมถึงเนื้อหาเกี่ยวกับโครงสร้างภายในโปรแกรมซึ่งจะประกอบด้วยเนื้อหาเกี่ยวกับลักษณะของโปรแกรมแบบโครงสร้าง  และรูปแบบโครงสร้างภายในโปรแกรม  เพื่อช่วยให้ผู้เขียนโปรแกรมสามารถเลือกใช้คำสั่งให้สอดคล้องกับโครงสร้างภายในโปรแกรมได้  ซึ่งรายละเอียดของแต่ละเนื้อหามีดังต่อไปนี้

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)  เพื่อใช้ในการอ้างอิงการเก็บข้อมูลและเรียกใช้ข้อมูลภายในตัวแปร   ดังนั้นผู้เขียนโปรแกรมจะต้องตั้งชื่อตัวแปรที่ใช้ในการเก็บข้อมูลทั้งหมดภายในโปรแกรม   รวมถึงตัวแปรบางตัวที่ใช้ในการนับจำนวนรอบของการทำงานในโปรแกรมอีกด้วย

จากตัวอย่างที่  1.1  สามารถแสดงการวิเคราะห์งานตั้งแต่ขั้นตอนที่  1  ถึง  4  ได้ดังนี้             1) วัตถุประสงค์ของการเขียนโปรแกรม             เพื่อคำนวณหาค่าพื้นที่สามเหลี่ยมมุมฉาก             2) รูปแบบผลลัพธ์ที่ต้องการ             พิมพ์ผลลัพธ์ที่ต้องการออกทางภาพดังนี้                         * ** output ***                         Base  =   5                         High   =   4                         Area   =   10             3) ข้อมูลนำเข้า  คือ  ความยาวฐานและความสูง             4) ตัวแปรที่ใช้                         B  =  ตัวแปรที่เก็บความยาวของสามเหลี่ยมมุมฉาก                           H  =  ตัวแปรที่เก็บความสูงของสามเหลี่ยมมุมฉาก                         Area  =    ตัวแปรที่เก็บผลลัพธ์ที่ได้จากการคำนวณตามสูตร                         Area  =   1/2*B*H               หรือ         Area  =   0.5*B*H

                       5) การหาขั้นตอนวิธีการทำงานของโปรแกรม
การหาขั้นตอนวิธีการทำงานของโปรแกรมจะขึ้นอยู่กับลักษณะของการแก้ปัญหา  ดังนั้นนักเขียนโปรแกรมที่มีความชำนาญในระดับหนึ่งแล้วจะสามารถหาขั้นตอนวิธีการทำงานของโปรแกรมได้โดยไม่ยาก แต่สำหรับผู้ที่เริ่มต้นศึกษาการเขียนโปรแกรม  ควรหาขั้นตอนวิธีการทำงานของโปรแกรมตามคำแนะนำโดยเรียงตามลำดับดังนี้
ขั้นตอนวิธีการทำงานของโปรแกรมที่แนะนำ

5.1) เริ่มต้นทำงาน             5.2) กำหนดค่าเริ่มต้นให้กับตัวแปร             5.3) พิมพ์หัวรายงาน  (ถ้ามีรายงาน)             5.4) รับข้อมูลเข้าทีละเรคอร์ด             5.5) ตรวจสอบข้อมูลว่าเป็นชุดสุดท้ายหรือไม่                         5.5.1  ถ้าเป็นข้อมูลชุดสุดท้าย   ให้ไปทำงานข้อ 5.11                         5.5.2 ถ้าไม่ใช่ข้อมูลชุดสุดท้าย  ให้ทำงานข้อต่อมา  (ข้อ 5.6)             5.6) คำนวณผลลัพธ์             5.7) เปรียบเทียบผลลัพธ์  (ถ้ามี)             5.8) เพิ่มค่าตัวแปรสะสม  (ถ้ามี)             5.9) พิมพ์ค่าผลลัพธ์ทีละเรคอร์ด             5.10) ย้อนกลับไปทำงานข้อ 5.4             5.11) พิมพ์สรุป  (ถ้ามี)             5.12) จบการทำงาน

            ทั้งนี้การวิเคราะห์งานเพื่อแก้ปัญหาแต่ละอย่างอาจมีบางขั้นตอนแตกต่างกันไป  ดังนั้นคำแนะนำข้างต้นจึงเป็นเพียงแนวทางของการหาขั้นตอนวิธีการทำงานของโปรแกรมเท่านั้น    ซึ่งเวลาใช้งานจริงผู้วิเคราะห์งานต้องประยุกต์ให้เข้ากับปัญหาที่ต้องการแก้ไขต่อไป
            เพื่อความเข้าใจเกี่ยวกับขั้นตอนวิธีการวิเคราะห์งานมากยิ่งขึ้น    ให้ศึกษาจากตัวอย่างการวิเคราะห์งานดังต่อไปนี้
            ตัวอย่างที่  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  ชุด  แล้วนำชุดที่สำเนาไปใช้    ไม่ควรใช้โปรแกรมต้นฉบับโดยตรง    ควรเก็บเอาไว้สำหรับกรณีที่โปรแกรมสำเนาเกิดปัญหาจะได้นำโปรแกรมต้นฉบับมาทำสำเนาและใช้งานได้ทันทีสำเนาและใช้งานได้ทันที