CHAPTER 8

ฟังก์ชัน
FUNCTIONS

ACTING SUB LT. CHAICHANA KULWORATIT, PH.D.

 ฟังก์ชัน

• ฟังก์ชันในภาษาซีแบ่งออกเป็น 2 ประเภท คือ

1. ฟังก์ชันมาตรฐานของภาษาซี (Standard Library Functions)
2. ฟังก์ชันที่ผู้เขียนโปรแกรมสร้างขึ้นเอง (User Defined Functions)
• โดยฟังก์ชันมาตรฐานของภาษาซีเป็นฟังก์ชันที่ภาษาซีได้จัดเตรียมไว้ให้กับผู้เขียน
โปรแกรมแล้ว ผู้เขียนโปรแกรมจึงสามารถเรียกใช้งานฟังก์ชันได้ทันที เพียงแต่ต้อง
ทราบก่อนว่าฟังก์ชันนั้นมีการประกาศไว้ในเฮดเดอร์ไฟล์ตัวใด แล้วเพิ่มบรรทัดคำสั่ง
#include <ชื่อเฮดเดอร์ไฟล์> เพื่อรวมเฮดเดอร์ไฟล์นั้นเข้าไว้ในการแปลโปรแกรมด้วย
• ส่วนฟังก์ชันอีกประเภทหนึ่ง ได้แก่ ฟังก์ชันสร้างเอง เป็นฟังก์ชันที่ผู้เขียนโปรแกรม
สร้างขึ้น เพื่อใช้จัดการกับปัญหาต่าง ๆ ตามที่ต้องการ
 ฟังก์ชันสร้างเอง

• ตั้งแต่บทแรก จะได้รู้จักฟังก์ชันหนึ่งเป็นอย่างดีแล้ว คือ ฟังก์ชัน main()

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

1 #include <stdio.h> 8 main()

9 {
2 int add(int a, int b) 10 int x, y, result;
3 { 11 printf("Please enter number1 : ");
12 scanf("%d", &x);
4 int sum; 13 printf("Please enter number2 : ");
5 sum = a+b; sum = a+b = 1+2 = 3 14 scanf("%d", &y);
15 result = add(x, y);
6 return sum; 16 printf("Result of %d + %d is %d\n", x, y, result);
7 } 17 }

result = add(X, Y);

ผลลัพธ์ของ
ส่งคืนค่ากลับออกไปเป็นชนิดข้อมูลจำนวนเต็ม โปรแกรม
 ฟังก์ชันสร้างเอง
1 main()
2 {
3 ...
1 int add(int a, int b)
4 ...
2 {
5 ...
3 int sum;
6 result = add(x, y);
4 sum = a+b;
7 ...
5 return sum;
8 ...
6 }
9 ...
10 }
 ฟังก์ชันสร้างเอง
อธิบายโปรแกรม
• บรรทัดที่ 2-7 เป็นฟังก์ชันที่ผู้เขียนโปรแกรมสร้างขึ้นเอง เพื่อใช้ในการหาผลบวกของเลขจำนวนเต็ม
2 จำนวน ซึ่งจะสังเกตเห็นว่าฟังก์ชันสร้างขึ้นเองนั้นจะถูกสร้างอยู่ภายนอกฟังก์ชันหลัก main() และ
• การทำงานจะเริ่มจากบรรทัดที่ 11-14 ทำการรับค่าเลขจำนวนเต็ม 2 จำนวน เข้ามาในโปรแกรม
ในที่นี้ได้ค่า x=1 และ y=2
• จากนั้นในบรรทัดที่ 15 ฟังก์ชันหลัก main() ทำการเรียกใช้งานฟังก์ชันย่อย add()
ที่ผู้เขียนโปรแกรมสร้างขึ้น ซึ่งขณะนี้การทำงานของโปรแกรมจะเข้าสู่ฟังก์ชันย่อยในบรรทัดที่ 2-7
โดยฟังก์ชันหลัก main() จะส่งค่า x และ y ไปยังฟังก์ชันย่อย add() ซึ่งฟังก์ชันย่อย add()
จะรับค่าตัวแปร x=1 ผ่านเข้ามาทางตัวแปร a และรับค่าตัวแปร y=2 ผ่านเข้ามาทางตัวแปร b
และทำการหาค่าผลบวกของ a และ b เก็บไว้ในตัวแปร sum จากนั้นเมื่อพบคำสั่ง return sum
ในบรรทัดที่ 6 แล้วโปรแกรมก็จะกลับไปทำงานในฟังก์ชันหลัก main() ดังเดิม
 ฟังก์ชันสร้างเอง
• เนื่องจากหน้าฟังก์ชันย่อย add() มีการระบุชนิดข้อมูลที่ส่งกลับมาเป็น int
• ดังนั้น ฟังก์ชันหลัก main() ที่ทำการเรียกใช้งานฟังก์ชันย่อย add() ก็ต้องจัดหา
ตัวแปรที่มีชนิดข้อมูลเป็นเลขจำนวนเต็ม (int) มารองรับค่าที่ฟังก์ชันย่อย add()
จะส่งคืนกลับมาให้ด้วย
• ซึ่งจากตัวอย่างจะพบว่าฟังก์ชันหลัก main() ได้นำตัวแปร result มารับค่าที่
ฟังก์ชันย่อย add() จะส่งคืนกลับมาให้ สำหรับหลักการทำงานของฟังก์ชัน
แต่ละประเภทจะได้กล่าวถึงโดยรายละเอียดในหัวข้อถัดไป
 โครงสร้างของฟังก์ชันสร้างเอง
• ฟังก์ชันสร้างเองมีรูปแบบ ดังนี้
ชนิดข้อมูลที่ต้องการส่งกลับออกไป ชื่อฟังก์ชัน(ชนิดข้อมูลที่รับเข้ามา ชื่อตัปรปรที่รับเข้ามา)
{
รูปแบบ ...
} ยกตัวอย่างเช่น

1 void add(void) • หมายถึง สร้างฟังก์ชัน add() ขึ้นใช้งาน

2 { โดยไม่มีการรับค่าใด ๆ เข้ามาในฟังก์ชัน และ
3 ... ไม่มีการส่งค่าใด ๆ กลับออกไปจากฟังก์ชัน
4 }
 โครงสร้างของฟังก์ชันสร้างเอง
1 void check(int a) • หมายถึง สร้างฟังก์ชัน check() ขึ้นใช้งาน
2 { โดยทำการรับค่าข้อมูลชนิดเลขจำนวนเต็ม
3 ... เข้ามาในฟังก์ชันผ่านทางตัวแปร a
4 } แต่ไม่มีการส่งค่าใด ๆ กลับออกไปจากฟังก์ชนั

1 float calculate(int a, int b) • หมายถึง สร้างฟังก์ชัน calculate() ขึ้นใช้งาน

2 { โดยทำการรับค่าข้อมูลชนิดเลขจำนวนเต็ม 2 ตัว
3 float c; เข้ามาในฟังก์ชันผ่านทางตัวแปร a และ b และ
4 ... หลักจากทำงานเรียบร้อยแล้วก็จะส่งค่าของ
5 return c; ตัวแปร c ซึ่งมีชนิดข้อมูลเป็นเลขจำนวนจริง
6 } (float) กลับออกไปจากฟังก์ชัน
 ประเภทของฟังก์ชันสร้างเอง
• ฟังก์ชันสร้างเองแบ่งออกเป็น 4 ประเภท คือ
1. ฟังก์ชันที่ไม่มีการรับค่าเข้ามาในฟังก์ชัน และไม่มีการส่งค่ากลับออกไปจากฟังก์ชัน
2. ฟังก์ชันที่มีการรับค่าเข้ามาในฟังก์ชัน แต่ไม่มีการส่งค่ากลับออกไปจากฟังก์ชัน
3. ฟังก์ชันที่มีการรับค่าเข้ามาในฟังก์ชัน และมีการส่งค่ากลับออกไปจากฟังก์ชัน
4. ฟังก์ชันที่ไม่มีการรับค่าเข้ามาในฟังก์ชัน แต่มีการส่งค่ากลับออกไปจากฟังก์ชัน
ฟังก์ชันที่ไม่มีการรับค่าเข้ามาในฟังก์ชัน และไม่มีการส่งค่ากลับออกไปจากฟังก์ชัน

• รูปแบบของฟังก์ชันประเภทนี้ คือ • ฟังก์ชันประเภทนี้เป็นฟังก์ชันที่สร้างได้ง่ายที่สุด

เมื่อเปรียบเทียบกับการสร้างฟังก์ชันในอีก 3 ประเภท
void ชื่อฟังก์ชันย่อย() • เนื่องจากฟังก์ชันประเภทนี้ไม่มีการรับค่าใด ๆ เข้ามาใน
{ ฟั ง ก์ ช น
ั และไม่ ม ก
ี ารส่ ง ค่ าใด ๆ กลั บ ออกไปจากฟั ง ก์ ช น
ั ด้ ว ย
รูปแบบ ... • ดังนั้น จึงไม่ต้องระมัดระวังในเรื่องของการรับส่งข้อมูล
} ระหว่างฟังก์ชัน ที่ต้องทำการรับส่งข้อมูลด้วยชนิดข้อมูล
เดียวกัน
• การเรียกใช้งานฟังก์ชันย่อยประเภทที่ไม่มีการรับค่าเข้ามาในฟังก์ชันและไม่มีการส่งคืนค่าใด ๆ
กลับออกไปจากฟังก์ชัน ทำได้โดยระบุ ดังนี้

รูปแบบ ชื่อฟังก์ชันย่อย();
ฟังก์ชันที่ไม่มีการรับค่าเข้ามาในฟังก์ชัน และไม่มีการส่งค่ากลับออกไปจากฟังก์ชัน
ตัวอย่าง โปรแกรมแสดงการทำงานของฟังก์ชันหลักร่วมกับการทำงานของฟังก์ชันสร้างเอง (ฟังก์ชันย่อย)

1 #include <stdio.h> 15 main()

2 ไม่รับค่าใด ๆ เข้ามาในฟังก์ชัน 16 {
3 void banner(void) (ไม่มี Argument) 17 banner(); เรียกใช้งาน
4 { 18 greeting(); ฟังก์ชันย่อย
5 printf("##############\n"); 19 }
6 printf("# C LANGUAGE #\n");
7 printf("##############\n");
8 }
ไม่ส่งคืนค่าใด ๆ
ผลลัพธ์ของโปรแกรม
9
10 void greeting(void) กลับออกไปจากฟังก์ชนั
11 {
12 printf("W l o e\n");
13 printf(" e c m to C Language\n");
14 }
ฟังก์ชันที่ไม่มีการรับค่าเข้ามาในฟังก์ชัน และไม่มีการส่งค่ากลับออกไปจากฟังก์ชัน
อธิบายโปรแกรม
• บรรทัดที่ 15 เริ่มต้นเข้าสู่การทำงานของฟังก์ชันหลัก main()
• บรรทัดที่ 17 ฟังก์ชันหลัก main() เรียกใช้งานฟังก์ชันย่อย banner() ซึง่ เมื่อฟังก์ชัน
ย่อย banner() ถูกเรียกใช้งานจะเข้าสู่การทำงานในบรรทัดที่ 3-8 เพื่อทำการพิมพ์
ข้อความในบรรทัดที่ 5-7 ออกทางจอภาพ ซึ่งเมื่อฟังก์ชันย่อย banner() ทำงานเสร็จ
แล้วก็จะคืนการทำงานให้กลับสู่การทำงานของฟังก์ชันหลัก คือ กลับไปทำงานใน
บรรทัดที่ 18 ของฟังก์ชันหลักต่อไป
• บรรทัดที่ 18 ฟังก์ชันหลัก main() เรียกใช้งานฟังก์ชันย่อย greeting() ซึง่ ก็จะข้าม
การทำงานในบรรทัดที่ 10-14 ของโปรแกรม เพื่อพิมพ์ข้อความบรรทัดที่ 12-13
ออกทางจอภาพ จากนั้นก็จะคืนการทำงานให้กลับสู่การทำงานของฟังก์ชันหลัก main()
ฟังก์ชันที่ไม่มีการรับค่าเข้ามาในฟังก์ชัน และไม่มีการส่งค่ากลับออกไปจากฟังก์ชัน

• จากการทำงานของฟังก์ชันย่อย banner() และ greeting()

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

1 #include <stdio.h> 11 void banner(void)

2 ประกาศเหมือนบรรทัดที่ 11 12 {
3 void banner(void); 13 printf("##############\n");
ทำการประกาศตัวแปร
4 void greeting(void); 14 printf("# C LANGUAGE #\n");
5 15 printf("##############\n");
6 main()
ประกาศเหมือนบรรทัดที่ 18 16 }
7 { 17
8 banner(); 18 void greeting(void)
9 greeting(); 19 {
10 } 20 printf("W l o e\n");
21 printf(" e c m to C Language\n");
22 }
ผลลัพธ์ของ
โปรแกรม
ฟังก์ชันที่ไม่มีการรับค่าเข้ามาในฟังก์ชัน และไม่มีการส่งค่ากลับออกไปจากฟังก์ชัน
• การเขียนโปรแกรมในรูปแบบนี้มีหลักการทำงานเหมือนกับโปรแกรมก่อนหน้าทุกประการ
และให้ผลลัพธ์ที่เหมือนกันทุกประการอีกด้วย
• เพียงแต่ว่าโปรแกรมนี้แตกต่างกับโปรแกรมก่อนหน้า ตรงที่โปรแกรมก่อนหน้าจะนำ
ฟังก์ชันหลัก main() วางไว้ใต้ฟังก์ชันย่อย แต่โปรแกรมนี้จะนำฟังก์ชันหลัก main()
วางไว้เหนือฟังก์ชันย่อยและทำการประกาศโปรโตไทป์ของฟังก์ชันดังในบรรทัดที่ 3 และ 4
เพื่อเป็นการประกาศให้ฟังก์ชันหลัก main() รู้จักฟังก์ชันย่อยทั้งสอง

• หากนำฟังก์ชันหลัก main() วางไว้เหนือฟังก์ชันย่อย โดยไม่ทำการประกาศ

โปรโตไทป์ของฟังก์ชันแล้ว โปรแกรมจะแจ้ง Error ว่า Type mismatch in
redeclaration of ‘banner’ และ Type mismatch in redeclaration of
‘greeting’ เนื่องจากมันไม่รู้จักฟังก์ชันย่อยทั้งสอง
ฟังก์ชันที่ไม่มีการรับค่าเข้ามาในฟังก์ชัน และไม่มีการส่งค่ากลับออกไปจากฟังก์ชัน

• รูปแบบของการจัดวางฟังก์ชันย่อยไว้ในโปรแกรมมี 2 รูปแบบ คือ

1. วางฟังก์ชัน main() ไว้ใต้ฟังก์ชันย่อย ไม่ต้องทำการประกาศ Function
Prototype เนื่องจากฟังก์ชันอยู่เหนือฟังก์ชัน main() สามารถรู้จัก
ฟังก์ชันย่อยนั้น ๆ ได้ (ล่างมองเห็นบน)
2. วางฟังก์ชัน main() ไว้เหนือฟังก์ชันย่อย ต้องทำการประกาศ Function
Prototype เพื่อให้ฟังก์ชัน main() รู้จักฟังก์ชันย่อยที่ได้สร้างขึ้น
เนื่องจาก main() อยู่บน และฟังก์ชันย่อยอยู่ล่าง ซึ่งบนจะมองไม่เห็นล่าง
 ฟังก์ชันที่ไม่มีการรับค่าเข้ามาในฟังก์ชัน และไม่มีการส่งค่ากลับออกไปจากฟังก์ชัน
ตัวอย่าง โปรแกรมแสดงการพิมพ์ต้นคริสต์มาสออกจอภาพ
1 #include <stdio.h> 30 main()
2
3
4
void merryXmas(void)
{
int x, y, z, space=4, check=0;
31
32
{
printf("Merry X'Mas For You\n");
ผลลัพธ์ของโปรแกรม
5 for(x=1; x<=9; x+=2)
6 {
33 merryXmas();
7 for(y=1; y<=x; y++) 34 printf("Wishing you happiness :)\n");
8 { 35 printf("\t\t From Santa hohoho\n");
9 if(check==0)
10 { 36 }
11 for(z=1; z<=space; z++)
12 {
13 printf(" ");
14 }
15 printf("*");
16 check=1;
17 }
18 else
19 {
20 printf("*");
21 }
22 }
23 printf("\n");
24 space--;
25 check=0;
26 }
27 printf(" ***\n");
28 printf(" ***\n");
29 }
ฟังก์ชันที่ไม่มีการรับค่าเข้ามาในฟังก์ชัน และไม่มีการส่งค่ากลับออกไปจากฟังก์ชัน
อธิบายโปรแกรม

• บรรทัดที่ 30-36 เป็นส่วนของฟังก์ชันหลัก main() โดยบรรทัดที่ 33 ฟังก์ชันหลัก

main() ทำการเรียกฟังก์ชันย่อย merryXmas() ให้ทำงาน
• บรรทัดที่ 2-29 เป็นส่วนของ ฟังก์ชันย่อย merryXmas() ซึ่งจะทำการพิมพ์
ภาพต้นคริสต์มาสออกทางจอภาพ ดังนี้
ฟังก์ชันที่ไม่มีการรับค่าเข้ามาในฟังก์ชัน และไม่มีการส่งค่ากลับออกไปจากฟังก์ชัน

*  พิมพ์ช่องว่าง 4 ช่อง ก่อนพิมพ์ * 1 ตัว

* * *  พิมพ์ช่องว่าง 3 ช่อง ก่อนพิมพ์ * 3 ตัว
* * * * *  พิมพ์ช่องว่าง 2 ช่อง ก่อนพิมพ์ * 5 ตัว
* * * * * * *  พิมพ์ช่องว่าง 1 ช่อง ก่อนพิมพ์ * 7 ตัว
* * * * * * * * *  พิมพ์ช่องว่าง 0 ช่อง ก่อนพิมพ์ * 9 ตัว
* * *  พิมพ์ช่องว่าง 3 ช่อง ก่อนพิมพ์ * 3 ตัว
* * *  พิมพ์ช่องว่าง 3 ช่อง ก่อนพิมพ์ * 3 ตัว
ฟังก์ชันที่ไม่มีการรับค่าเข้ามาในฟังก์ชัน และไม่มีการส่งค่ากลับออกไปจากฟังก์ชัน
• โดยการทำงานจะแบ่งออกเป็น 3 ลูปการทำงาน คือ
1. ก่อนพิมพ์ * ต้องพิมพ์ช่องว่างก่อนเสมอ ดังนั้น ลูปชั้นในสุดบรรทัดที่ 11-14
จึงเป็นลูปที่ใช้สำหรับพิมพ์ช่องว่าง โดยใช้ตัวแปร space เป็นตัวควบคุม
o โดยรอบแรกตัวแปร space จะมีค่าเท่ากับ 4 คือ พิมพ์ช่องว่าง 4 ช่อง
o ซึ่งในรอบต่อ ๆ ไป จะทำการลดค่าของตัวแปร space ลงเป็น 3, 2, 1, 0 ตามลำดับ
o และเมื่อพิมพ์ช่องว่างครบแล้วจึงจะทำการพิมพ์ * 1 ตัว
o จากนั้นทำการเปลี่ยนค่าตัวแปร check เป็น 1 เนื่องจากการพิมพ์ช่องว่างจะทำแค่
รอบแรกรอบเดียวเท่านั้น รอบต่อไปที่ทำการพิมพ์ * ไม่ต้องพิมพ์ช่องว่างอีก
กล่าวคือ หากยังไม่เคยพิมพ์ * ก็ต้องพิมพ์ช่องว่างก่อน (พิมพ์ช่องว่างตามจำนวน
ที่ต้องการพิมพ์ในลูปนั้น ๆ)
ฟังก์ชันที่ไม่มีการรับค่าเข้ามาในฟังก์ชัน และไม่มีการส่งค่ากลับออกไปจากฟังก์ชัน
o ซึ่งเมื่อพิมพ์ช่องว่างเสร็จแล้วก็จะทำการพิมพ์ * ซึ่งเมื่อพิมพ์ * ไปแล้ว 1 ตัว รอบต่อไป
ก็จะพิมพ์ * เรียงต่อจาก * ตัวเดิมเลย โดยไม่ต้องพิมพ์ช่องว่างอีก
o โดยจะใช้ตัวแปร check เป็นตัวตรวจสอบ โดยถ้า check=0 หมายถึง รอบแรก
(ต้องพิมพ์ช่องว่าง) แต่ถ้า check=1 หมายถึง รอบต่อ ๆ ไปที่ไม่ใช่รอบแรก
(ไม่ต้องพิมพ์ช่องว่าง)
o ดังนั้น จะเห็นว่าเมื่อพิมพ์ช่องว่างพร้อมด้วย * ตัวแรกไปแล้ว ในบรรทัดที่ 16
จะสั่ง check=1 เพื่อที่ครั้งต่อไปจะได้ไม่ตอ้ งทำการพิมพ์ช่องว่างอีก
2. เมื่อพิมพ์ช่องว่างแล้วต่อมาจะเป็นการพิมพ์ * ออกทางจอภาพ ดังนั้น ลูปชั้นถัดมาใน
บรรทัดที่ 7-22 จึงเป็นลูปที่ใช้ควบคุมการพิมพ์ * โดยจะทำการตรวจสอบค่าตัวแปร
check ก่อน เพื่อจะได้ทราบว่าจะต้องพิมพ์ช่องว่างก่อนหรือพิมพ์ * ได้ทันที
3. เมื่อพิมพ์ช่องว่างและ * ในบรรทัดหนึ่ง ๆ เรียบร้อยแล้ว ก็จะต้องทำการขึ้นบรรทัดใหม่
โดยลูปนอกสุดในบรรทัดที่ 5-26 นั้น จะทำการควบคุม ดังนี้
ฟังก์ชันที่ไม่มีการรับค่าเข้ามาในฟังก์ชัน และไม่มีการส่งค่ากลับออกไปจากฟังก์ชัน
• บรรทัดที่ 23 สั่งให้ขึ้นบรรทัดใหม่
• บรรทัดที่ 24 สั่งลดค่า space ด้วย space--; สำหรับใช้ควบคุมว่าในรอบต่อไปนี้
จะต้องพิมพ์ช่องว่างกี่ช่อง
• บรรทัดที่ 25 สั่ง reset ค่า check กลับเป็น 0 เหมือนเดิม เนื่องจากเป็น
รอบการทำงานใหม่แล้ว ดังนั้น ต้องทำการพิมพ์ช่องว่างก่อนที่จะพิมพ์ * ด้วย
• และในลูปนี้จะควบคุมจำนวน * ที่จะต้องพิมพ์ด้วย โดยสังเกตบรรทัดที่ 5
จะสั่งพิมพ์ค่า x ครั้งละ 2 (x+=2) ทำให้ในแต่ละรอบมีการพิมพ์ * เพิม่ ขึ้น
ครั้งละ 2 ตัว คือ จะพิมพ์ * จาก 1 ตัวเป็น 3, 5, 7, 9 ตัว ตามลำดับ
• และเมื่อจบการทำงานของทั้ง 3 ลูปแล้ว บรรทัดที่ 27 และ 28 ก็จะสั่งพิมพ์
ฐานของต้นคริสต์มาส โดยพิมพ์ช่องว่าง 3 ช่อง และ * 3 ตัว
 ฟังก์ชันที่มีการรับค่าเข้ามาในฟังก์ชัน แต่ไม่มีการส่งค่ากลับออกไปจากฟังก์ชัน
• รูปแบบของฟังก์ชันประเภทนี้ คือ
void ชื่อฟังก์ชันย่อย(ชนิดข้อมูลที่รับเข้ามา ชื่อตัวแปรที่รับเข้ามา)
{
รูปแบบ ... • ฟังก์ชันประเภทนี้มีการรับค่าเข้ามาในฟังก์ชันย่อยด้วย
} • โดยฟังก์ชันหลัก main() จะทำการสั่งค่าพารามิเตอร์ (Parameter) มายัง
ฟังก์ชันย่อย และฟังก์ชันย่อยจะต้องกำหนดอาร์กิวเมนต์ (Argument) ขึ้น
เพื่อรองรับค่าพารามิเตอร์ที่ฟังก์ชันหลัก main() จะส่งมาให้
• การเรียกใช้งานฟังก์ชันย่อยประเภทที่มีการรับค่าเข้ามาในฟังก์ชัน แต่ไม่มีการส่งคืนค่าใด ๆ
กลับออกไปจากฟังก์ชัน ทำได้โดยระบุ ดังนี้

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

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

1 void test(int a, float b) • จะเห็นว่าฟังก์ชันหลัก main() ส่งพารามิเตอร์

2 { 2 ตัว คือ
3 ... 1. ตัวแปร a ที่มีชนิดข้อมูลเลขจำนวนเต็ม
4 } 2. ตัวแปร average ที่มีชนิดข้อมูลเลข
5 main()
จำนวนจริง
6 {
7 int a=3;
• ไปยังฟังก์ชัน test()
8 float average=5.5; • โดยฟังก์ชัน test() ได้ตั้งตัวแปรอาร์กิวเมนต์
9 test(a,average); 2 ตัว คือ a และ b ไว้สำหรับรับค่าพารามิเตอร์
10 } ที่จะส่งมา
ฟังก์ชันที่มีการรับค่าเข้ามาในฟังก์ชัน แต่ไม่มีการส่งค่ากลับออกไปจากฟังก์ชัน

• การกำหนดชนิดข้อมูลของอาร์กิวเมนต์แต่ละตัว จะต้องพิจารณาจากชนิดข้อมูลของ
พารามิเตอร์ที่จะส่งมาเป็นหลัก
• กล่าวคือ ต้องระวังในเรื่องการกำหนดชนิดข้อมูลของอาร์กิวเมนต์ให้มีชนิดข้อมูลเป็น
ชนิดเดียวกับพารามิเตอร์ที่จะส่งมาด้วย เช่น จากตัวอย่างก่อนหน้า ฟังก์ชันหลัก
main() ส่งค่าพารามิเตอร์ตัวแรก คือ a มีชนิดข้อมูลเป็น int ดังนั้น อาร์กิวเมนต์
ตัวแรกของฟังก์ชัน test() ก็ต้องกำหนดชนิดข้อมูลเป็น int ด้วย และส่ง
ค่าพารามิเตอร์ตัวที่สอง คือ average มีชนิดข้อมูลเป็น float ดังนั้น อาร์กิวเมนต์
ตัวที่สองของฟังก์ชัน test() ก็ต้องกำหนดชนิดข้อมูลเป็น float เป็นต้น
• ให้ระมัดระวังในเรื่องของชนิดข้อมูลให้ดี เพราะหากกำหนดชนิดข้อมูลไม่ตรงตัว
กันแล้ว จะทำให้เกิดข้อผิดพลาดขึ้นกับโปรแกรมได้
 ฟังก์ชันที่มีการรับค่าเข้ามาในฟังก์ชัน แต่ไม่มีการส่งค่ากลับออกไปจากฟังก์ชัน
14 main()
ตัวอย่าง โปรแกรมการเลือกลบหรือหารตัวเลข 15
16
{
int choice, num1, num2;
17 do
18 {
กำหนดอาร์กิวเมนต์ตัวที่ 1 คือ ตัวแปร a 19 printf("Calculate\n");
1 #include <stdio.h> 20 printf("1. Substract\n");
2 เป็นชนิดข้อมูล int สำหรับค่าพารามิเตอร์ตัวที่ 1 21 printf("2. Divide\n");
22 printf("3. Exit\n");
3 void substract(int a,int b) คือ ค่า num1 และตัวแปร b เป็นชนิดข้อมูล int 23 printf("Select choice : ");
สำหรับค่าพารามิเตอร์ที่ 2 คือ ค่า num2 24 scanf("%d", &choice);
4 { 25
26 if(choice < 1 || choice > 3)
5 printf("Result of %d-%d is %d\n\n", a, b, a-b); 27 printf("Please enter choice 1-3 only\n\n");
6 } 28 else if(choice == 3)
29 break;
7 30 else
31 {
8 void divide(int a, int b) 3 32 6 printf("Enter number1 : ");
9 { 33
34
scanf("%d", &num1);
printf("Enter number2 : ");
10 float result; 35 scanf("%d", &num2);
เรียกใช้งานฟังก์ชันย่อย 36 if(choice==1)
11 result = (float)a/b; 37 substract(num1, num2);
38 else
12 printf("Result of %d/%d is %f\n\n", a, b, result); 39 divide(num1, num2);
13 } 40 }
ส่งพารามิเตอร์ num1, num2 ซึ่งมีชนิดข้อมูล 41 }
42 while(choice != 3);
เป็น int ไปยังฟังก์ชันย่อย 43 }
ฟังก์ชันที่มีการรับค่าเข้ามาในฟังก์ชัน แต่ไม่มีการส่งค่ากลับออกไปจากฟังก์ชัน

ผลลัพธ์ของโปรแกรม

อธิบายโปรแกรม
• บรรทัดที่ 17-42 เป็นการใช้ลูป do-while กำหนดการทำงานของ
ฟังก์ชันหลัก main() โดยการทำงานของโปรแกรมจะมี 3
เมนูให้เลือกใช้งาน คือ 1. การลบ 2. การหาร 3. ออกจากโปรแกรม
ซึ่งโปรแกรมจะวนลูปทำงานไปเรื่อย ๆ จนกว่าผู้ใช้งานโปรแกรม
จะเลือกเมนูที่ 3 คือ ออกจากโปรแกรม จึงจะจบการทำงานของ
โปรแกรม
• บรรทัดที่ 19-24 เป็นการแสดงผลเมนู และรอรับค่าการเลือกของผู้ใช้
 ฟังก์ชันที่มีการรับค่าเข้ามาในฟังก์ชัน แต่ไม่มีการส่งค่ากลับออกไปจากฟังก์ชัน
• บรรทัดที่ 26-27 เป็นการนำค่าเมนูที่ผู้ใช้งานเลือกมาทำการตรวจสอบ
o ถ้าผู้ใช้งานเลือกเมนูที่ไม่ใช่ 1-3 ก็จะแสดงข้อความเตือนในบรรทัดที่ 27 ให้เลือกเมนูที่ 1-3
เท่านั้น
o หากผู้ใช้งานโปรแกรมเลือกเมนูที่ 3 ก็จะเข้าสู่การทำงานในบรรทัดที่ 28-29 โดยคำสั่ง break
เป็นการสั่งให้ออกจากการทำงานของลูป do-while
o แต่หากผู้ใช้งานโปรแกรมเลือกเมนู 1-2 ก็จะเข้าสู่การทำงานในบรรทัดที่ 30-40
โดยในบรรทัดที่ 32-35 จะรับค่าตัวเลข 2 ตัวเข้ามาในโปรแกรม โดยเมื่อป้อนค่าตัวเลข
เรียบร้อยแล้ว ก็จะพิจารณาว่าผู้ใช้งานโปรแกรมเลือกเมนูใด
o ถ้าเลือกเมนูที่ 1 ก็จะไปทำงานในบรรทัดที่ 37 คือ เรียกฟังก์ชันย่อย substract() ให้ทำงาน
โดยส่งค่าเลขจำนวนเต็ม num1 และ num2 ไปยังฟังก์ชันย่อยด้วย
o แต่ถ้าเลือกเมนูที่ 2 ก็จะไปทำงานบรรทัดที่ 39 คือ เรียกฟังก์ชันย่อย divide() ให้ทำงาน และ
ส่งค่า num1, num2 ไปยังฟังก์ชันย่อยนัน้ ด้วย
 ฟังก์ชันที่มีการรับค่าเข้ามาในฟังก์ชัน แต่ไม่มีการส่งค่ากลับออกไปจากฟังก์ชัน
• บรรทัดที่ 3-6 เป็นการทำงานของฟังก์ชันย่อย substract() ซึ่งจะรับค่า num1
ผ่านเข้ามาทางตัวแปร a และรับค่า num2 ผ่านเข้ามาทางตัวแปร b จากนั้นทำการ
พิมพ์ค่าผลลัพธ์ของ a-b ออกทางจอภาพ
• บรรทัดที่ 8-13 เป็นการทำงานของฟังก์ชันย่อย divide() ซึ่งจะรับค่า num1 และ
num2 ผ่านเข้ามาทางตัวแปร a และ b ตามลำดับ จากนั้นบรรทัดที่ 11 ทำ Explicit
Type Conversion เพื่อแปลงชนิดข้อมูลของผลลัพธ์ที่ได้จาก int ไปเป็น float
ก่อนนำผลหารที่ได้เก็บลงตัวแปร result ที่มีชนิดข้อมูลเป็นเลขจำนวนจริง และ
พิมพ์ผลลัพธ์นั้นออกทางจอภาพ
 ฟังก์ชันที่มีการรับค่าเข้ามาในฟังก์ชัน แต่ไม่มีการส่งค่ากลับออกไปจากฟังก์ชัน
ตัวอย่าง โปรแกรมแสดงค่ารหัสแอสกี
1 #include <stdio.h>
2
ผลลัพธ์ของโปรแกรม
3 void ascii_char(int num)
4 {
5 printf("Your character is %c\n", num);
6 }
7
8 main()
97
Please enter number between 1-255 : 97
9 { Your character is a
10 int number;
11 printf("Please enter number between 1-255 : ");
12 scanf("%d", &number);
13 ascii_char(number);
14 }