หน่วยที่ 7 ฟังก์ชันในภาษา C

สำหรับเนื้อหาในบทนี้จะกล่าวถึงฟังก์ชันในภาษา C โดยจะประกอบไปด้วยเนื้อหาหลัก ๆ คือ เรื่องที่หนึ่ง ฟังก์ชันมาตรฐาน เป็นฟังก์ชันที่บริษัทที่ผลิตภาษา C ได้เขียนขึ้นและเก็บไว้ใน header file ภาษา C คือเก็บไว้ในแฟ้มที่มีนามสกุล *.h ต่าง ๆ ส่วนเรื่องที่สอง เป็นฟังก์ชันที่เขียนขึ้นหรือเรียกอีกอย่างว่าโปรแกรมย่อย ที่ผู้เขียนโปรแกรมเขียนขึ้นมาใช้งานอย่างใดอย่างหนึ่งตามความต้องการของงานนั้น ๆ โดยรายละเอียดของแต่ละฟังก์ชันมีดังต่อไปนี้

7.1 ฟังก์ชันมาตรฐาน (standard functions)

เป็นฟังก์ชันที่บริษัทที่ผลิตภาษา C ได้เขียนขึ้นและเก็บไว้ใน header file ภาษา C คือเก็บไว้ในแฟ้มที่มีนามสกุล *.h ต่าง ๆ เมื่อต้องการใช้ฟังก์ชันใด จะต้องรู้ว่าฟังก์ชันนั้นอยู่ใน header file ใดจากนั้นจึงค่อยใช้คำสั่ง #include<header file.h> เข้ามาในส่วนตอนต้นของโปรแกรม จึงจะสามารถใช้ฟังก์ชันที่ต้องการได้ ซึ่งฟังก์ชันมาตรฐานเป็นฟังก์ชันที่บริษัทผู้ผลิต C compiler เขียนขึ้นเพื่อให้ผู้ใช้นำไปช่วยในการเขียนโปรแกรมทำให้การเขียนโปรแกรมสะดวกและง่ายขึ้น บางครั้งเราอาจจะเรียกฟังก์ชันมาตรฐานว่า ”ไลบรารีฟังก์ชัน” (library functions)

ตัวอย่างที่ 7.1 แสดงตัวอย่างฟังก์ชันมาตรฐาน เช่น ฟังก์ชัน pow(x,y) คือ ฟังก์ชันที่ใช้หาค่ายกกำลังของ xy โดยที่ตัวแปร x และตัวแปร y มีชนิดเป็น double ซึ่งฟังก์ชัน pow(x,y) จะถูกเก็บไว้ใน header file ที่ชื่อว่า math.h ดังนั้นจึงต้องใช้คำสั่ง #include<math.h> แทรกอยู่ในส่วนตอนต้นของโปรแกรมเหนือฟังก์ชัน main( ) จึงจะสามารถเรียกใช้ฟังก์ชัน pow(x,y) มาใช้งานภายในโปรแกรมนี้ได้

สำหรับฟังก์ชันมาตรฐานที่จะกล่าวถึงในหัวข้อนี้จะกล่าว เฉพาะฟังก์ชันมาตรฐานที่จำเป็น และเรียกใช้งานบ่อย ๆ เท่านั้น ซึ่งมีดังต่อไปนี้

7.1.1 ฟังก์ชันทางคณิตศาสตร์ (mathematic functions)

เป็นฟังก์ชันที่ใช้สำหรับการคำนวณทางคณิตศาสตร์ และก่อนที่จะใช้ฟังก์ชันประเภทนี้ จะต้องใช้คำสั่ง #include <math.h> แทรกอยู่ตอนต้นของโปรแกรม และตัวแปรที่จะใช้ฟังก์ชันประเภทนี้จะต้องมีชนิด (type) เป็น double เนื่องจากผลลัพธ์ที่ได้จากฟังก์ชันประเภทนี้จะได้ค่าส่งกลับของข้อมูลเป็น double เช่นกัน

ฟังก์ชันทางคณิตศาสตร์ที่ควรทราบ มีดังนี้

acos(x) asin(x) atan(x)

sin(x) cos(x) tan(x)

sqrt(x) exp(x) pow(x,y)

log(x) log10(x) ceil(x)

floor(x) fabs(x)

1) ฟังก์ชัน acos(x)

เป็นฟังก์ชันที่ใช้คำนวณหาค่า arc cosine ของ x โดยที่ x เป็นค่ามุมในหน่วยเรเดียน (radian)

รูปแบบ

acos(x);

2) ฟังก์ชัน asin(x)

เป็นฟังก์ชันที่ใช้คำนวณหาค่า arc sine ของ x โดยที่ x เป็นค่ามุมในหน่วยเรเดียน

รูปแบบ

asin(x);

3) ฟังก์ชัน atan(x)

เป็นฟังก์ชันที่ใช้คำนวณหาค่า arc tan ของ x โดยที่ x เป็นค่ามุมในหน่วย

เรเดียน

รูปแบบ

atan(x);

4) ฟังก์ชัน sin(x)

เป็นฟังก์ชันที่ใช้คำนวณหาค่า sine ของ x โดยที่ x เป็นค่ามุมในหน่วยเรเดียน

รูปแบบ

sin(x);

5) ฟังก์ชัน cos(x)

เป็นฟังก์ชันที่ใช้คำนวณหาค่า cosine ของ x โดยที่ x เป็นค่ามุมในหน่วย

เรเดียน

รูปแบบ

cos(x);

6) ฟังก์ชัน tan(x)

เป็นฟังก์ชันที่ใช้คำนวณหาค่า tan ของ x โดยที่ x เป็นค่ามุมในหน่วยเรเดียน

รูปแบบ

tan(x);

เพื่อความเข้าใจการใช้งานฟังก์ชัน acos(x), asin(x), atan(x), sin(x), cos(x) และ tan(x) มากยิ่งขึ้น ให้ศึกษาโปรแกรมตัวอย่างต่อไปนี้

โปรแกรมตัวอย่างที่ 7.1 แสดงการใช้งานฟังก์ชัน acos(x), asin(x), atan(x), sin(x), cos(x) และ tan(x)

/* math1.c */

#include<stdio.h> /* บรรทัดที่ 1 */

#include<math.h> /* บรรทัดที่ 2 */

#include<conio.h> /* บรรทัดที่ 3 */

void main(void) /* บรรทัดที่ 4 */

{ /* บรรทัดที่ 5 */

double r, pi = 3.141592654; /* บรรทัดที่ 6 */

r = pi/180; /* บรรทัดที่ 7 */

clrscr(); /* บรรทัดที่ 8 */

printf("%f\n",asin(r)); /* บรรทัดที่ 9 */

printf("%f\n",acos(r)); /* บรรทัดที่ 10 */

printf("%f\n",atan(r)); /* บรรทัดที่ 11 */

printf("%f\n",sin(r)); /* บรรทัดที่ 12 */

printf("%f\n",cos(r)); /* บรรทัดที่ 13 */

printf("%f\n",tan(r)); /* บรรทัดที่ 14 */

printf("\nPress any key back to program ..."); /* บรรทัดที่ 15 */

getch(); /* บรรทัดที่ 16 */

} /* บรรทัดที่ 17 */

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

คำอธิบายโปรแกรม

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

บรรทัดที่ 9 คำสั่ง printf("%f\n",asin(r)); ฟังก์ชันคำนวณหาค่า arc sin ของตัวแปร r โดย r เป็นมุมในหน่วยเรเดียน และแสดงผลลัพธ์ที่ได้ออกจอภาพ

บรรทัดที่ 10 คำสั่ง printf("%f\n",acos(r)); ฟังก์ชันคำนวณหาค่า arc cosine ของตัวแปร r โดย r เป็นมุมในหน่วยเรเดียน และแสดงผลลัพธ์ที่ได้ออกจอภาพ

บรรทัดที่ 11 คำสั่ง printf("%f\n",atan(r)); ฟังก์ชันคำนวณหาค่า arc tan ของตัวแปร r โดย r เป็นมุมในหน่วยเรเดียน และแสดงผลลัพธ์ที่ได้ออกจอภาพ

บรรทัดที่ 12 คำสั่ง printf("%f\n",sin(r)); ฟังก์ชันคำนวณหาค่า sine ของตัวแปร r โดย r เป็นมุมในหน่วยเรเดียน และแสดงผลลัพธ์ที่ได้ออกจอภาพ

บรรทัดที่ 13 คำสั่ง printf("%f\n",cos(r)); ฟังก์ชันคำนวณหาค่า cosine ของตัวแปร r โดย r เป็นมุมในหน่วยเรเดียน และแสดงผลลัพธ์ที่ได้ออกจอภาพ

บรรทัดที่ 14 คำสั่ง printf("%f\n",tan(r)); ฟังก์ชันคำนวณหาค่า tan ของตัวแปร r โดย r เป็นมุมในหน่วยเรเดียน และแสดงผลลัพธ์ที่ได้ออกจอภาพ

บรรทัดที่ 15 และ 16 พิมพ์ข้อความให้กดคีย์ใด ๆ เพื่อกลับสู่โปรแกรม และหยุดรอรับค่าใด ๆ เช่น กด enter จะกลับเข้าสู่โปรแกรม

7) ฟังก์ชัน sqrt(x)

เป็นฟังก์ชันที่ใช้หาค่ารากที่ 2 (square root) ของค่าคงที่หรือตัวแปร x โดยที่ x จะต้องเป็นค่าคงที่ชนิดตัวเลขหรือตัวแปรที่มีค่าไม่ติดลบ

รูปแบบ

sqrt(x);

8) ฟังก์ชัน exp(x)

เป็นฟังก์ชันที่ใช้หาค่า ex โดยที่ x เป็นค่าคงที่หรือตัวแปรที่จะใช้เป็นค่ายกกำลังของ e โดยที่ e มีค่าประมาณ 2.718282

รูปแบบ

exp(x);

9) ฟังก์ชัน pow(x,y)

เป็นฟังก์ชันที่ใช้หาค่า xy

โดยที่

x เป็นค่าคงที่หรือตัวแปรที่ใช้เป็นตัวฐานซึ่งจะต้องมีค่ามากกว่าศูนย์

y เป็นค่าคงที่หรือตัวแปรที่ใช้เป็นค่ายกกำลัง

รูปแบบ

pow(x, y);

เพื่อความเข้าใจการใช้งานฟังก์ชัน sqrt(x), exp(x) และ pow(x, y) มากยิ่งขึ้นให้ศึกษาโปรแกรมตัวอย่างต่อไปนี้

โปรแกรมตัวอย่างที่ 7.2 แสดงการใช้งานฟังก์ชัน sqrt(x), exp(x) และ pow(x, y)

/* math2.c */

#include<stdio.h> /* บรรทัดที่ 1 */

#include<math.h> /* บรรทัดที่ 2 */

#include<conio.h> /* บรรทัดที่ 3 */

void main(void) /* บรรทัดที่ 4 */

{ /* บรรทัดที่ 5 */

double x = 2.5, y = 7.0, z = 21.5; /* บรรทัดที่ 6 */

clrscr( ); /* บรรทัดที่ 7 */

printf("%.4f\n",pow(x,y)); /* บรรทัดที่ 8 */

printf("%.4f\n",sqrt(z)); /* บรรทัดที่ 9 */

printf("%.4f\n",exp(y)); /* บรรทัดที่ 10 */

printf("\nPress any key back to program ..."); /* บรรทัดที่ 11 */

getch(); /* บรรทัดที่ 12 */

} /* บรรทัดที่ 13 */

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

คำอธิบายโปรแกรม

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

บรรทัดที่ 8 คำสั่ง printf("%.4f\n",pow(x,y)); ฟังก์ชันคำนวณหาค่า xy โดยที่ x เป็นค่าคงที่หรือตัวแปรที่ใช้ตัวฐานซึ่งจะต้องมีค่ามากกว่าศูนย์ และ y เป็นค่าคงที่หรือตัวแปรที่ใช้เป็นค่ายกกำลัง และแสดงผลที่ได้ออกจอภาพ

บรรทัดที่ 9 คำสั่ง printf("%.4f\n",sqrt(z)); ฟังก์ชันคำนวณหาค่ารากที่สอง (square root) ของค่าคงที่หรือตัวแปร z โดยที่ z จะต้องเป็นค่าคงที่ชนิดตัวเลขหรือตัวแปรที่มีค่าไม่ติดลบ และแสดงผลที่ได้ออกจอภาพ

บรรทัดที่ 10 คำสั่ง printf("%.4f\n",exp(y)); ฟังก์ชันคำนวณหาค่า ey โดยที่ y เป็นค่าคงที่หรือตัวแปรที่จะใช้เป็นค่ายกกำลังของ e โดยที่ e มีค่าประมาณ 2.718282 และแสดงผลที่ได้ออกจอภาพ

บรรทัดที่ 11 และ 12 พิมพ์ข้อความให้กดคีย์ใด ๆ เพื่อกลับสู่โปรแกรม และหยุดรอรับค่าใด ๆ เช่น กด enter จะกลับเข้าสู่โปรแกรม

10) ฟังก์ชัน log(x)

เป็นฟังก์ชันที่ใช้หาค่า log ฐาน n (natural logarithm) ของค่าคงที่หรือตัวแปร x โดยที่ x เป็นค่าคงที่หรือตัวแปรที่มีค่าเป็นลบไม่ได้

รูปแบบ

log(x);

11) ฟังก์ชัน log10(x)

เป็นฟังก์ชันที่ใช้หาค่า log ฐาน 10 ของค่าคงที่หรือตัวแปร x โดยที่ x เป็นค่าคงที่หรือตัวแปรที่มีค่าเป็นลบไม่ได้

รูปแบบ

log10(x);

เพื่อความเข้าใจการใช้งานฟังก์ชัน log(x) และ log10(x) มากยิ่งขึ้น ให้ศึกษาโปรแกรมตัวอย่างต่อไปนี้

โปรแกรมตัวอย่างที่ 7.3 แสดงการใช้งานฟังก์ชัน log(x) และ log10(x)

/* math3.c */

#include<stdio.h> /* บรรทัดที่ 1 */

#include<math.h> /* บรรทัดที่ 2 */

#include<conio.h> /* บรรทัดที่ 3 */

void main(void) /* บรรทัดที่ 4 */

{ /* บรรทัดที่ 5 */

double m = 10.0, n = 3.0; /* บรรทัดที่ 6 */

clrscr( ); /* บรรทัดที่ 7 */

printf("%.4f\n",log(n)); /* บรรทัดที่ 8 */

printf("%.4f\n",log10(m)); /* บรรทัดที่ 9 */

printf("\nPress any key back to program ..."); /* บรรทัดที่ 10 */

getch(); /* บรรทัดที่ 11 */

} /* บรรทัดที่ 12 */

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

คำอธิบายโปรแกรม

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

บรรทัดที่ 8 คำสั่ง printf(“%.4f\n”,log(n)); ฟังก์ชันที่ใช้หาค่า log ฐาน n (natural logorithm) ของค่าคงที่หรือตัวแปร n โดยที่ n เป็นค่าคงที่หรือตัวแปรที่มีค่าเป็นลบไม่ได้ และแสดงผลที่ได้ออกจอภาพ

บรรทัดที่ 9 คำสั่ง printf("%.4f\n",log10(m)); ฟังก์ชันที่ใช้หาค่า log ฐาน 10 ของค่าคงที่หรือตัวแปร m โดยที่ m เป็นค่าคงที่หรือตัวแปรที่มีค่าเป็นลบไม่ได้ และแสดงผลที่ได้ออกจอภาพ

บรรทัดที่ 10 และ 11 พิมพ์ข้อความให้กดคีย์ใด ๆ เพื่อกลับสู่โปรแกรม และหยุดรอรับค่าใด ๆ เช่น กด enter จะกลับเข้าสู่โปรแกรม

12) ฟังก์ชัน ceil(x)

เป็นฟังก์ชันที่ใช้ในการปัดเศษทศนิยมขึ้นของตัวแปร x ถ้า x เป็นตัวเลขจำนวนทศนิยม แต่ถ้า x เป็นเลขจำนวนเต็มจะไม่มีการปัดเศษทศนิยม

รูปแบบ

ceil(x);

13) ฟังก์ชัน floor(x)

เป็นฟังก์ชันที่ใช้ในการตัดเศษทศนิยมทิ้งของตัวแปร x ถ้า x เป็นตัวเลขจำนวนทศนิยม แต่ถ้า x เป็นเลขจำนวนเต็มจะไม่มีการตัดเศษทศนิยมทิ้ง

รูปแบบ

floor(x);

เพื่อความเข้าใจการใช้งานฟังก์ชัน ceil(x) และ floor(x) มากยิ่งขึ้น ให้ศึกษาโปรแกรมตัวอย่างต่อไปนี้

โปรแกรมตัวอย่างที่ 7.4 แสดงการใช้งานฟังก์ชัน ceil(x) และ floor(x)

/* math4.c */

#include<stdio.h> /* บรรทัดที่ 1 */

#include<math.h> /* บรรทัดที่ 2 */

#include<conio.h> /* บรรทัดที่ 3 */

void main(void) /* บรรทัดที่ 4 */

{ /* บรรทัดที่ 5 */

clrscr(); /* บรรทัดที่ 6 */

printf("%.4f\n", ceil(9.8765)); /* บรรทัดที่ 7 */

printf("%.4f\n", ceil(-3.7654)); /* บรรทัดที่ 8 */

printf("%.4f\n", ceil(80)); /* บรรทัดที่ 9 */

printf("%.4f\n", floor(7.9876)); /* บรรทัดที่ 10 */

printf("%.4f\n", floor(-3.321)); /* บรรทัดที่ 11 */

printf("%.4f\n", floor(180)); /* บรรทัดที่ 12 */

printf("\nPress any key back to program ..."); /* บรรทัดที่ 13 */

getch(); /* บรรทัดที่ 14 */

} /* บรรทัดที่ 15 */

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

คำอธิบายโปรแกรม

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

บรรทัดที่ 7 คำสั่ง printf(“%.4f\n”,ceil(9.8765)); ฟังก์ชันที่ใช้ในการปัดเศษทศนิยมขึ้นของตัวเลข 9.8765 และแสดงผลออกที่จอภาพ

บรรทัดที่ 8 คำสั่ง printf(“%.4f\n”,ceil(-3.7654)); ฟังก์ชันที่ใช้ในการปัดเศษทศนิยมขึ้นของตัวเลข -3.7654 และแสดงผลออกที่จอภาพ

บรรทัดที่ 9 คำสั่ง printf(“%.4f\n”,ceil(80)); ฟังก์ชันที่ใช้ในการปัดเศษทศนิยมขึ้นของตัวเลข 80 และแสดงผลออกที่จอภาพ

บรรทัดที่ 10 คำสั่ง printf(“%.4f\n”,floor(7.9876)); ฟังก์ชันที่ใช้ในการตัดเศษทศนิยมทิ้งของตัวเลข 7.9876 และแสดงผลออกที่จอภาพ

บรรทัดที่ 11 คำสั่ง printf(“%.4f\n”,floor(-3.321)); ฟังก์ชันที่ใช้ในการตัดเศษทศนิยมทิ้งของตัวเลข -3.321 และแสดงผลออกที่จอภาพ

บรรทัดที่ 12 คำสั่ง printf(“%.4f\n”,floor(180)); ฟังก์ชันที่ใช้ในการตัดเศษทศนิยมทิ้งของตัวเลข 180 และแสดงผลออกที่จอภาพ

บรรทัดที่ 13 และ 14 พิมพ์ข้อความให้กดคีย์ใด ๆ เพื่อกลับสู่โปรแกรม และหยุดรอรับค่าใด ๆ เช่น กด enter จะกลับเข้าสู่โปรแกรม

14. ฟังก์ชัน fabs(x)

เป็นฟังก์ชันที่ใช้หาค่าสัมบูรณ์ (absolute value) ของค่าคงที่หรือตัวแปร x โดยที่ x เป็นค่าคงที่หรือตัวแปรที่เก็บค่าตัวเลขจุดทศนิยมที่มีค่าบวกหรือลบก็ได้

รูปแบบ

fabs(x);

เพื่อความเข้าใจการใช้งานฟังก์ชัน fabs(x) มากยิ่งขึ้น ให้ศึกษาโปรแกรมตัวอย่างต่อไปนี้

โปรแกรมตัวอย่างที่ 7.5 แสดงการใช้งานฟังก์ชัน fabs(x)

/* math5.c */

#include<stdio.h> /* บรรทัดที่ 1 */

#include<math.h> /* บรรทัดที่ 2 */

#include<conio.h> /* บรรทัดที่ 3 */

void main(void) /* บรรทัดที่ 4 */

{ /* บรรทัดที่ 5 */

double x = 123.4567, y = -891.2345; /* บรรทัดที่ 6 */

clrscr(); /* บรรทัดที่ 7 */

printf("Absolute value of x = %.5f\n",fabs(x)); /* บรรทัดที่ 8 */

printf("Absolute value of y = %.5f\n",fabs(y)); /* บรรทัดที่ 9 */

printf("\nPress any key back to program ..."); /* บรรทัดที่ 10 */

getch(); /* บรรทัดที่ 11 */

} /* บรรทัดที่ 12 */

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

คำอธิบายโปรแกรม

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

บรรทัดที่ 8 และ 9 ใช้ฟังก์ชัน fabs( ) หาค่าสัมบูรณ์ (absolute value) ของค่าคงที่หรือตัวแปร x และ y และแสดงผลออกที่จอภาพ ตามลำดับ

7.1.2 ฟังก์ชันเกี่ยวกับตัวอักษร (character functions)

เป็นฟังก์ชันที่ใช้กับข้อมูลที่มีชนิดเป็น single char (ใช้เนื้อที่ 1 byte) เท่านั้น และก่อนที่จะใช้ฟังก์ชันประเภทนี้จะต้องใช้คำสั่ง #include<ctype.h> แทรกอยู่ตอนต้นของโปรแกรม จึงจะสามารถเรียกใช้ฟังก์ชันประเภทนี้ได้

ฟังก์ชันที่เกี่ยวกับตัวอักษรที่ควรทราบ มีดังนี้

isalnum(ch) isalpha(ch) isdigit(ch)

islower(ch) isupper(ch)

tolower(ch) toupper(ch)

isspace(ch) isxdigit(ch)

โดยมีรายละเอียดของฟังก์ชันแต่ละฟังก์ชันดังต่อไปนี้

1) ฟังก์ชัน isalnum(ch)

เป็นฟังก์ชันที่ใช้ตรวจสอบว่าข้อมูลที่เก็บไว้ในตัวแปร ch เป็นตัวอักษรหรือตัวเลข (letter or digit) ถ้าข้อมูลที่เก็บไว้เป็นตัวอักษรหรือตัวเลขก็จะส่งค่ากลับที่เป็นจำนวนเต็มที่มีค่าไม่เท่ากับศูนย์มายังฟังก์ชัน และถ้าข้อมูลที่เก็บไว้ในตัวแปร ch ไม่ได้เก็บตัวอักษรหรือตัวเลขก็จะส่งค่ากลับที่มีค่าเป็นศูนย์มายังฟังก์ชัน

รูปแบบ

isalnum(ch);

2) ฟังก์ชัน isalpha(ch)

เป็นฟังก์ชันที่ใช้ตรวจสอบว่าข้อมูลที่เก็บไว้ในตัวแปร ch เป็นตัวอักษร (letter) หรือไม่ ถ้าใช่ฟังก์ชันนี้จะให้ค่าส่งกลับเป็นเลขจำนวนเต็มที่ไม่เท่ากับศูนย์ ถ้าไม่ใช่ฟังก์ชันนี้จะให้ค่าส่งกลับมาเป็นเลขศูนย์ (0)

รูปแบบ

isalpha(ch);

3) ฟังก์ชัน isdigit(ch)

เป็นฟังก์ชันที่ใช้ตรวจสอบว่าข้อมูลที่เก็บไว้ในตัวแปร ch เป็นตัวเลข 0 ถึง 9 หรือไม่ ถ้าใช่ฟังก์ชันนี้จะให้ค่าส่งกลับเป็นเลขจำนวนเต็มที่ไม่เท่ากับศูนย์ ถ้าไม่ใช่ฟังก์ชันนี้จะไม่มีการส่งค่ากลับ

รูปแบบ

isdigit(ch);

เพื่อความเข้าใจการใช้งานฟังก์ชัน isalnum(ch), isalpha(ch) และ isdigit(ch) มากยิ่งขึ้น ให้ศึกษาโปรแกรมตัวอย่างต่อไปนี้

โปรแกรมตัวอย่างที่ 7.6 แสดงการใช้งานฟังก์ชัน isalnum(ch), isalpha(ch) และ isdigit(ch)

/* char1.c */

#include<stdio.h> /* บรรทัดที่ 1 */

#include<ctype.h> /* บรรทัดที่ 2 */

#include<conio.h> /* บรรทัดที่ 3 */

void main(void) /* บรรทัดที่ 4 */

{ /* บรรทัดที่ 5 */

char ch1 = '6', ch2 = 'K', ch3 = '*'; /* บรรทัดที่ 6 */

clrscr( ); /* บรรทัดที่ 7 */

printf("%d\n",isalnum(ch1)); /* บรรทัดที่ 8 */

printf("%d\n",isalnum(ch2)); /* บรรทัดที่ 9 */

printf("%d\n",isalnum(ch3)); /* บรรทัดที่ 10 */

printf("%d\n",isalpha(ch1)); /* บรรทัดที่ 11 */

printf("%d\n",isalpha(ch2)); /* บรรทัดที่ 12 */

printf("%d\n",isalpha(ch3)); /* บรรทัดที่ 13 */

printf("%d\n",isdigit(ch1)); /* บรรทัดที่ 14 */

printf("%d\n",isdigit(ch2)); /* บรรทัดที่ 15 */

printf("%d\n",isdigit(ch3)); /* บรรทัดที่ 16 */

printf("\nPress any key back to program ..."); /* บรรทัดที่ 17 */

getch(); /* บรรทัดที่ 18 */

} /* บรรทัดที่ 19 */

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

คำอธิบายโปรแกรม

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

บรรทัดที่ 8 ถึง 10 ใช้ฟังก์ชัน isalnum( ) ใช้ตรวจสอบว่าข้อมูลที่เก็บไว้ในตัวแปร ch1, ch2 และ ch3 ตามลำดับ เป็นตัวอักษรหรือตัวเลข ซึ่งถ้าข้อมูลที่เก็บไว้เป็นตัวอักษรหรือตัวเลขจะส่งค่ากลับที่เป็นจำนวนเต็มที่มีค่าไม่เท่ากับศูนย์มายังฟังก์ชัน แต่ถ้าข้อมูลในตัวแปรไม่ได้เก็บตัวอักษรหรือตัวเลขจะส่งค่าศูนย์กลับมายังฟังก์ชัน แล้วแสดงผลที่ได้ออกมาจอภาพ

บรรทัดที่ 11 ถึง 13 ใช้ฟังก์ชัน isalpha( ) ใช้ตรวจสอบว่าข้อมูลในตัวแปร ch1, ch2 และ ch3 ตามลำดับ เป็นตัวอักษรหรือไม่ ถ้าใช่ฟังก์ชันจะให้ค่ากลับเป็นเลขจำนวนเต็มที่ไม่เท่ากับศูนย์ ถ้าไม่ใช่ฟังก์ชันจะให้ค่ากลับเป็นศูนย์ แล้วแสดงผลที่ได้ออกจอภาพ

บรรทัดที่ 14 ถึง 16 ใช้ฟังก์ชัน isdigit( ) ใช้ตรวจสอบว่าข้อมูลที่เก็บในตัวแปร ch1, ch2 และ ch3 ตามลำดับ เป็นตัวเลข 0 ถึง 9 หรือไม่ ถ้าใช่ฟังก์ชันจะให้ค่ากลับเป็นเลขจำนวนเต็มที่ไม่เท่ากับศูนย์ ถ้าไม่ใช่ฟังก์ชันจะไม่มีการส่งค่ากลับ

บรรทัดที่ 17 และ 18 พิมพ์ข้อความให้กดคีย์ใด ๆ เพื่อกลับสู่โปรแกรม และหยุดรอรับค่าใด ๆ เช่น กด enter จะกลับเข้าสู่โปรแกรม

4) ฟังก์ชัน islower(ch)

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

รูปแบบ

islower(ch);

5) ฟังก์ชัน isupper(ch)

เป็นฟังก์ชันที่ใช้ตรวจสอบว่าข้อมูลที่เก็บไว้ในตัวแปร ch เป็นตัวอักษรตัวใหญ่หรือไม่ ถ้าใช่ให้ส่งค่ากลับเป็นเลขจำนวนเต็มที่ไม่เท่ากับศูนย์ ถ้าไม่ใช่ฟังก์ชันนี้จะให้ค่าส่งกลับเป็นเลขศูนย์ (0)

รูปแบบ

isupper(ch);

6) ฟังก์ชัน tolower(ch)

เป็นฟังก์ชันที่ใช้เปลี่ยนตัวอักษรตัวใหญ่ที่เก็บไว้ในตัวแปร ch ให้เป็นอักษรตัวเล็ก

รูปแบบ

tolower(ch);

7) ฟังก์ชัน toupper(ch)

เป็นฟังก์ชันที่ใช้เปลี่ยนตัวอักษรตัวเล็กที่เก็บไว้ในตัวแปร ch ให้เป็นอักษรตัวใหญ่

รูปแบบ

toupper(ch);

เพื่อความเข้าใจการใช้งานฟังก์ชัน islower(ch), isupper(ch), tolower(ch) และ toupper(ch) มากยิ่งขึ้น ให้ศึกษาโปรแกรมตัวอย่างต่อไปนี้

โปรแกรมตัวอย่างที่ 7.7 แสดงการใช้งานฟังก์ชัน islower(ch), isupper(ch), tolower(ch) และ toupper(ch)

/* char2.c */

#include<stdio.h> /* บรรทัดที่ 1 */

#include<ctype.h> /* บรรทัดที่ 2 */

#include<conio.h> /* บรรทัดที่ 3 */

void main(void) /* บรรทัดที่ 4 */

{ /* บรรทัดที่ 5 */

char ch1 = 'm', ch2 = 'N'; clrscr( ); /* บรรทัดที่ 6 */

printf("%d\t%d\n",islower(ch1),islower(ch2)); /* บรรทัดที่ 7 */

printf("%d\t%d\n",isupper(ch1),isupper(ch2)); /* บรรทัดที่ 8 */

printf("%c\t%c\n",tolower(ch1),toupper(ch2)); /* บรรทัดที่ 9 */

printf("\nPress any key back to program ..."); /* บรรทัดที่ 10 */

getch(); /* บรรทัดที่ 11 */

} /* บรรทัดที่ 12 */

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

คำอธิบายโปรแกรม

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

บรรทัดที่ 7 ใช้ฟังก์ชัน islower( ) ตรวจสอบตัวอักษรที่เก็บไว้ในตัวแปร ch1 และ ch2 เป็นตัวอักษรตัวพิมพ์เล็กหรือไม่ ถ้าใช่ฟังก์ชันจะให้ค่ากลับเป็นเลขจำนวนเต็มที่ไม่เท่ากับศูนย์ ถ้าไม่ใช่ฟังก์ชันจะให้ค่ากลับเป็นเลขศูนย์ แล้วแสดงผลออกที่จอภาพ

บรรทัดที่ 8 ใช้ฟังก์ชัน isupper( ) ตรวจสอบตัวอักษรที่เก็บไว้ในตัวแปร ch1 และ ch2 เป็นตัวอักษรตัวพิมพ์ใหญ่หรือไม่ ถ้าใช่ฟังก์ชันจะให้ค่ากลับเป็นเลขจำนวนเต็มที่ไม่เท่ากับศูนย์ ถ้าไม่ใช่ฟังก์ชันจะให้ค่ากลับเป็นเลขศูนย์ แล้วแสดงผลออกที่จอภาพ

บรรทัดที่ 9 ใช้ฟังก์ชัน tolower( ) ใช้เปลี่ยนตัวอักษรตัวพิมพ์ใหญ่ที่เก็บไว้ในตัวแปร ch1 ให้เป็นตัวอักษรตัวพิมพ์เล็ก และใช้ฟังก์ชัน toupper( ) ใช้เปลี่ยนตัวอักษรตัวพิมพ์เล็กที่เก็บไว้ในตัวแปร ch2 ให้เป็นตัวอักษรตัวพิมพ์ใหญ่ แล้วแสดงผลออกจอภาพ

8) ฟังก์ชัน isspace(ch)

เป็นฟังก์ชันที่ใช้ตรวจสอบว่าค่าข้อมูลที่อยู่ในตัวแปร ch มีค่าเป็น whitespace หรือไม่ (whitespace) ได้แก่ space, tab, vertical tab, formfeed, carriage return และ new line ถ้าเป็น whitespace เพียงแค่ตัวใดตัวหนึ่ง ฟังก์ชันนี้จะให้ค่าส่งกลับที่เป็นเลขจำนวนเต็มที่ไม่เท่ากับศูนย์ถ้าไม่ป็น whitespace ฟังก์ชันนี้จะให้ค่าส่งกลับเป็นเลขศูนย์ (0)

รูปแบบ

isspace(ch);

9) ฟังก์ชัน isxdigit(ch)

เป็นฟังก์ชันที่ใช้ตรวจสอบว่าข้อมูลตัวเลขที่อยู่ในตัวแปร ch เป็นตัวเลขฐานสิบหก (0-9, A-F, หรือ a-f) หรือไม่ ถ้าใช่ฟังก์ชันนี้จะมีการส่งค่ากลับตัวเลขที่ไม่เท่ากับศูนย์มายังฟังก์ชัน ถ้าไม่ใช่ฟังก์ชันนี้จะส่งค่าเป็นตัวเลขศูนย์กลับมายังฟังก์ชัน

รูปแบบ

isxdigit(ch);

เพื่อความเข้าใจการใช้งานฟังก์ชัน isspace(ch) และ isxdigit(ch) มากยิ่งขึ้น ให้ศึกษาโปรแกรมตัวอย่างต่อไปนี้

โปรแกรมตัวอย่างที่ 7.8 แสดงการใช้งานฟังก์ชัน isspace(ch) และ isxdigit(ch)

/* char3.c */

#include<stdio.h> /* บรรทัดที่ 1 */

#include<ctype.h> /* บรรทัดที่ 2 */

#include<conio.h> /* บรรทัดที่ 3 */

void main(void) /* บรรทัดที่ 4 */

{ /* บรรทัดที่ 5 */

char ch1 = '\0', ch2 = '\n', ch3 = '\t', ch4 = 'J' ; /* บรรทัดที่ 6 */

clrscr( ); /* บรรทัดที่ 7 */

printf("%d\t%d\n",isspace(ch1),isspace(ch2)); /* บรรทัดที่ 8 */

printf("%d\t%d\n",isspace(ch3),isxdigit(ch4)); /* บรรทัดที่ 9 */

printf("\nPress any key back to program ..."); /* บรรทัดที่ 10 */

getch(); /* บรรทัดที่ 11 */

} /* บรรทัดที่ 12 */

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

คำอธิบายโปรแกรม

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

บรรทัดที่ 8 ใช้ฟังก์ชัน isspace( ) ตรวจสอบว่าข้อมูลที่อยู่ในตัวแปร ch1 และ ch2 มีค่าเป็น whitespace หรือไม่ ถ้าเป็นฟังก์ชันจะให้ค่ากลับที่เป็นเลขจำนวนเต็มที่ไม่เท่ากับศูนย์ ถ้าไม่ใช่ฟังก์ชันจะให้ค่ากลับเป็นเลขศูนย์ แล้วแสดงผลที่ได้ออกจอภาพ

บรรทัดที่ 9 ใช้ฟังก์ชัน isspace( ) ตรวจสอบว่าข้อมูลที่อยู่ในตัวแปร ch3 มีค่าเป็น whitespace หรือไม่ ถ้าเป็นฟังก์ชันจะให้ค่ากลับที่เป็นเลขจำนวนเต็มที่ไม่เท่ากับศูนย์ ถ้าไม่ใช่ฟังก์ชันจะให้ค่ากลับเป็นเลขศูนย์ แล้วแสดงผลที่ได้ออกจอภาพ และใช้ฟังก์ชัน isxdigit( ) ตรวจสอบว่าข้อมูลตัวเลขที่อยู่ในตัวแปร ch4 ว่าเป็นตัวเลขฐานสิบหกหรือไม่ ถ้าใช่ฟังก์ชันจะส่งค่ากลับเป็นตัวเลขที่ไม่เท่ากับศูนย์ ถ้าไม่ใช่ฟังก์ชันจะส่งตัวเลขศูนย์กลับมายังฟังก์ชัน

7.1.3 ฟังก์ชันเกี่ยวกับสตริง (string functions)

เป็นฟังก์ชันที่ใช้กับข้อมูลชนิดสตริง (string) โดยก่อนที่จะใช้ฟังก์ชันประเภทนี้จะต้องใช้คำสั่ง #include<string.h> แทรกอยู่ตอนต้นของโปรแกรมเสียก่อน จึงจะเรียกใช้ฟังก์ชันประเภทนี้ได้

ฟังก์ชันที่เกี่ยวข้องกับสตริงที่ควรทราบ มีดังนี้

strlen(s) strcmp(s1,s2)

strcpy(s) strcat(s1,s2)

สำหรับรายละเอียดของฟังก์ชันแต่ละฟังก์ชันได้เคยกล่าวมาแล้วในบทที่ 5 เกี่ยวกับ array และ string จึงไม่ขอกล่าวซ้ำอีก

7.1.4 ฟังก์ชันทั่วไปที่ใช้งานบ่อย ๆ

จะกล่าวเฉพาะฟังก์ชันที่ใช้บ่อย ๆ เท่านั้น ซึ่งมีฟังก์ชันดังนี้

1) ฟังก์ชัน clrscr( )

เป็นฟังก์ชันที่ใช้ในการลบข้อมูลออกจากจอภาพแบบ text mode

รูปแบบ

clrscr( );

2) ฟังก์ชัน gotoxy(x,y)

เป็นฟังก์ชันที่ใช้คำสั่งให้ตัวชี้ตำแหน่ง (cursor) เคลื่อนที่ไปยังตำแหน่งที่ระบุไว้บนจอภาพ

รูปแบบ

gotoxy(x,y );

โดยที่

x คือ ตำแหน่ง column บนจอมีค่าตั้งแต่ 1 ถึง 79 ส่วน column ที่ 80 สงวนไว้

y คือ ตำแหน่ง row บนจอภาพมีค่าตั้งแต่ 1 ถึง 24 ส่วน row ที่ 25 สงวนไว้

3) ฟังก์ชัน clreol( )

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

รูปแบบ

clreol( );

4) ฟังก์ชัน deline( )

เป็นฟังก์ชันที่ใช้ลบข้อความทั้งบรรทัดที่มีตัว cursor อยู่ จากนั้นก็เลื่อนข้อความในบรรทัดที่อยู่ข้างล่างขึ้นมาแทนที่

รูปแบบ

deline( );

5) ฟังก์ชัน insline( )

เป็นฟังก์ชันที่ใช้แทรกบรรทัดว่าง 1 บรรทัด โดยแทรกอยู่ใต้บรรทัดที่มี cursor อยู่

รูปแบบ

insline( );

6) ฟังก์ชัน sizeof(x)

เป็นฟังก์ชันที่ใช้ตรวจสอบขนาดของตัวแปร x ว่ามีขนาดกี่ Byte

รูปแบบ

sizeof(x);

หรือ sizeof(type);

โดยที่

x เป็นชื่อตัวแปรที่ต้องการตรวจสอบขนาด

type เป็นชนิดของตัวแปร เช่น int, float, char, double เป็นต้น

7) ฟังก์ชัน system( )

เป็นฟังก์ชันที่ช่วยให้สามารถเรียกใช้คำสั่งที่อยู่ใน MS-DOS มาใช้งานได้

รูปแบบ

system(“dos-command”);

โดยที่

dos-command คือคำสั่ง dos ที่ต้องการใช้ เช่น cls, dir, date, time, etc. เป็นต้น

8) ฟังก์ชัน abort( )

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

รูปแบบ

abort( );

9) ฟังก์ชัน abs(x)

เป็นฟังก์ชันที่ใช้ค่าสัมบูรณ์ของ x โดยที่ x เป็นตัวแปรที่เก็บตัวเลขจำนวนเต็มเท่านั้น

รูปแบบ

abs(x);

เช่น int x = -65;

printf(“%d”, abs(x));

ผลลัพธ์ที่ได้ คือค่า 65

10) ฟังก์ชัน labs(x)

เป็นฟังก์ชันที่ใช้หาค่าสมบูรณ์ของ x โดยที่ x เป็นตัวแปรที่เก็บตัวเลขชนิด long integer

รูปแบบ

labs(x);

11) ฟังก์ชัน atoi(s)

เป็นฟังก์ชันที่เปลี่ยนค่า string ให้เป็นตัวเลขจำนวนเต็ม (integer) ที่สามารถนำไปคำนวณได้

รูปแบบ

atoi(s);

ตัวอย่างที่ 7.2 แสดงการใช้ฟังก์ชัน atoi( )

char numstr[20] = “1000”; int d;

d = atoi(numstr);

printf (“%d”, d);

ผลลัพธ์ที่ได้คือค่าตัวเลข 1000

12) ฟังก์ชัน atof(s)

เป็นฟังก์ชันที่ใช้เปลี่ยนค่า string ให้เป็นตัวเลขจำนวนทศนิยม (floating point) ที่สามารถนำไปคำนวณได้

รูปแบบ

atof( );

ตัวอย่างเช่นที่ 7.3 แสดงการใช้ฟังก์ชัน atof

char numstr[ 20 ] = “10.45” ; float f;

f = atof (numstr);

printf( “% .2f”, f );

ผลลัพธ์ที่ได้คือค่าตัวเลข 10.45

13) ฟังก์ชัน atol(s)

เป็นฟังก์ชันที่ใช้เปลี่ยนค่า string ให้เป็นตัวเลขจำนวนเต็มชนิด long integer ที่สามารถนำไปใช้คำนวณได้

รูปแบบ

atol(s);

เพื่อความเข้าใจการใช้งานฟังก์ชัน atoi( ), atof( ) และ atol( ) มากยิ่งขึ้น ให้ศึกษาโปรแกรมตัวอย่างต่อไปนี้

โปรแกรมตัวอย่างที่ 7.9 แสดงการใช้งานฟังก์ชัน atoi( ), atof( ) และ atol( )

/* atoifl.c */

#include<stdio.h> /* บรรทัดที่ 1 */

#include<stdlib.h> /* บรรทัดที่ 2 */

#include<conio.h> /* บรรทัดที่ 3 */

void main(void) /* บรรทัดที่ 4 */

{ /* บรรทัดที่ 5 */

char s1[5] = "123"; /* บรรทัดที่ 6 */

char s2[10] = "14.573"; /* บรรทัดที่ 7 */

char s3[15] = "1234567891"; /* บรรทัดที่ 8 */

int as1; float fs2; long ls3; /* บรรทัดที่ 9 */

clrscr( ); /* บรรทัดที่ 10 */

as1 = 2 * atoi(s1); /* บรรทัดที่ 11 */

fs2 = 2 * atof(s2); /* บรรทัดที่ 12 */

ls3 = atol(s3); /* บรรทัดที่ 13 */

printf("AS1 = %d\n",as1); /* บรรทัดที่ 14 */

printf("FS2 = %f\n",fs2); /* บรรทัดที่ 15 */

printf("LS3 = %ld\n",ls3); /* บรรทัดที่ 16 */

printf("\nPress any key back to program ..."); /* บรรทัดที่ 17 */

getch(); /* บรรทัดที่ 18 */

} /* บรรทัดที่ 19 */

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

คำอธิบายโปรแกรม

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

บรรทัดที่ 11 ใช้ฟังก์ชัน atoi( ) เปลี่ยนค่าสตริง s1 ให้เป็นตัวเลขจำนวนเต็มที่สามารถนำไปคำนวณได้ ซึ่งในคำสั่งนี้จะใช้คูณกับเลข 2 เก็บไว้ที่ตัวแปร as1

บรรทัดที่ 12 ใช้ฟังก์ชัน atof( ) เปลี่ยนค่าสตริง s2 ให้เป็นตัวเลขทศนิยมที่สามารถนำไปคำนวณได้ ซึ่งในคำสั่งนี้จะใช้คูณกับเลข 2 เก็บไว้ที่ตัวแปร fs2

บรรทัดที่ 13 ใช้ฟังก์ชัน atol( ) เปลี่ยนค่าสตริง s3 ให้เป็นตัวเลขจำนวนเต็มชนิด long integer เก็บไว้ที่ตัวแปร ls3

บรรทัดที่ 14 ถึง 16 แสดงค่าของตัวแปร as1, fs2 และ as3 ตามลำดับ แสดงผลที่ได้ออกจอภาพ

7.2 ฟังก์ชันที่เขียนขึ้น (user defined functions)

ฟังก์ชันที่เขียนขึ้นหรือบางครั้งเราเรียกว่าโปรแกรมย่อย คือ ส่วนของโปรแกรมที่เขียนขึ้นเพื่อให้สามารถทำงานได้อย่างใดอย่างหนึ่งตามความต้องการ สำหรับผู้เขียนโปรแกรมภาษา Cนิยมเรียกโปรแกรมย่อยว่า ”ฟังก์ชัน” ส่วนผู้ที่เขียนโปรแกรมภาษาปาสคาล โคบอล ฟอร์แทรน เบสิก นิยมเรียกว่า ”โปรแกรมย่อย” อย่างไรก็ตามโปรแกรมย่อยหรือฟังก์ชันก็มีลักษณะการทำงานเหมือนกัน เพียงแต่เรียกชื่อต่างกันเท่านั้นสำหรับในเอกสารนี้จะเรียกว่า ฟังก์ชัน ซึ่งในเนื้อหาส่วนนี้ จะเป็นการเรียนรู้เกี่ยวกับฟังชันที่เขียนขึ้น (user define functions : UDF) ตั้งแต่การประกาศรูปแบบฟังก์ชัน การเขียนตัวฟังก์ชันและการเรียกใช้ฟังก์ชันเพื่อให้สามารถใช้ฟังก์ชันที่เขียนขึ้นในโปรแกรมภาษา C ได้อย่างถูกต้อง

ตัวอย่างที่ 7.4 แสดงฟังก์ชันที่เขียนขึ้นเพื่อใช้งานอย่างใดอย่างหนึ่ง เช่น

void asterisk_line( ) {

int j, n=30;

for(j=1; j<=n; j++)

printf(“*”);

}

ฟังก์ชัน asterisk_line( ) เป็นฟังก์ชันที่ใช้พิมพ์เครื่องหมาย * (asterisk) จำนวน 30 ตัวออกทางจอภาพ

7.2.1 ประเภทของฟังก์ชันที่เขียนขึ้น

(types of user defined functions )

ในการเขียนฟังก์ชันขึ้นมาใช้งานอย่างใดอย่างหนึ่ง เราสามารถจำแนกฟังก์ชันที่เขียนขึ้นตามลักษณะการส่งค่าไปและรับค่ากลับได้ 3 แบบ คือ

1) ฟังก์ชันที่ไม่มีการส่งค่าไปและรับค่ากลับ

2) ฟังก์ชันที่มีการส่งค่าไปแต่ไม่มีรับค่ากลับ

3) ฟังก์ชันที่มีทั้งการส่งค่าไปและรับค่ากลับ

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

7.2.2 โครงสร้างของฟังก์ชัน (the structure of functions)

ฟังก์ชันที่สร้างขึ้นมาแต่ละฟังก์ชันจะประกอบด้วยโครงสร้างดังนี้

รูปแบบโครงสร้างของฟังก์ชันในภาษา C

type function_name(type1 arg1, type2 arg2,.., typeN argN)

{

local variable declaration;

statement(s);

return( varlue);

}

โดยที่

type คือ ชนิดของข้อมูลที่ส่งกลับมายังชื่อฟังก์ชันที่เรียกใช้ โดยปกติแล้วถ้าไม่มีการกำหนด type ว่าเป็นชนิด int, float, char หรือ double จะได้ค่าข้อมูลที่ส่งกลับมาเป็นชนิด int เสมอ ยกเว้นว่าฟังก์ชันนั้นไม่มีการส่งค่ากลับจะต้องกำหนดให้ type เป็น void

function_name คือ ชื่อฟังก์ชัน ซึ่งเราสามารถตั้งชื่อฟังก์ชันโดยอาศัยกฎเกณฑ์ของการตั้งชื่อตัวแปรในภาษาซี

type1 arg1, type2 arg2,…, typeN argN คือ การประกาศชื่อและชนิดของตัวแปรที่จะใช้เป็น argument ตัวที่ 1, 2, 3,…, N ตามลำดับ ถ้าเป็นฟังก์ชันที่ไม่มีทั้งการส่งค่าไปและรับค่ากลับเลย ให้ใช้คำว่า void แทน

{ คือ จุดเริ่มต้นของฟังก์ชัน

} คือจุดสิ้นสุดของฟังก์ชัน

local variable declaration คือ การประกาศชนิดและชื่อของตัวแปรที่ใช้ได้เฉพาะภายในฟังก์ชัน ถ้าอยู่นอกฟังก์ชันจะไม่สามารถใช้ตัวแปร local ที่ประกาศไว้ได้

statement(s) คือ คำสั่งต่าง ๆ ที่ใช้ในฟังก์ชัน ถ้ามีมากกว่า 1 คำสั่งให้จบท้ายแต่ละคำสั่งด้วยเครื่องหมาย ; (semicolon)

return(value) คือ คำสั่งที่ใช้ส่งค่ากลับไปยังชื่อฟังก์ชันที่เรียกใช้ ส่วน value ที่อยู่ภายใน ( ) คือ ค่าที่จะถูกส่งกลับ คำสั่งนี้จะใช้เฉพาะฟังก์ชันที่มีการส่งค่ากลับเท่านั้น ถ้าเป็นฟังก์ชันที่ไม่มีทั้งการส่งค่าไปและกลับ หรือเป็นฟังก์ชันชนิดที่มีแต่การส่งค่าไปอย่างเดียว ก็ไม่ต้องใช้คำสั่งนี้

โปรแกรมตัวอย่างที่ 7.10 แสดงโครงสร้างของฟังก์ชัน

/* funct1.c */

#include<stdio.h> /* บรรทัดที่ 1 */

#include<conio.h> /* บรรทัดที่ 2 */

void one(void); /* function Prototype */ /* บรรทัดที่ 3 */

void two(void); /* function Prototype */ /* บรรทัดที่ 4 */

void main(void) /* บรรทัดที่ 5 */

{ /* บรรทัดที่ 6 */

clrscr(); /* บรรทัดที่ 7 */

one(); /* call one() */ /* บรรทัดที่ 8 */

two(); /* call two() */ /* บรรทัดที่ 9 */

printf("\nPress any key back to program ..."); /* บรรทัดที่ 10 */

getch(); /* บรรทัดที่ 11 */

} /* end main */ /* บรรทัดที่ 12 */

/* one function */ /* บรรทัดที่ 13 */

void one() /* บรรทัดที่ 14 */

{ /* บรรทัดที่ 15 */

int a=5, b=7; /* บรรทัดที่ 16 */

printf("A = %d, B = %d\n",a,b); /* บรรทัดที่ 17 */

} /* บรรทัดที่ 18 */

/* two function */ /* บรรทัดที่ 19 */

void two() /* บรรทัดที่ 20 */

{ /* บรรทัดที่ 21 */

float p=4.5, q=3.5; /* บรรทัดที่ 22 */

p+=q; /* บรรทัดที่ 23 */

printf("P = %6.3f, Q = %6.3f\n",p,q); /* บรรทัดที่ 24*/

} /* บรรทัดที่ 25 */

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

คำอธิบายโปรแกรม

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

บรรทัดที่ 3 และ 4 คำสั่ง void one(void); และ void two(void); คำสั่งประกาศชื่อฟังก์ชันและชนิดของการส่งค่ากลับมายังฟังก์ชัน ซึ่งในกรณีนี้ทั้งฟังก์ชัน one( ) และ two( ) เป็นฟังก์ชันชนิดที่ไม่มีทั้งการส่งค่าไปและรับค่ากลับ เนื่องจากคำว่า void ที่อยู่หน้าชื่อฟังก์ชัน one( ) และ two( ) เป็นการบอกว่าไม่มีการรับค่าที่ส่งกลับ ส่วนคำว่า void ที่อยู่ภายใน ( ) ของฟังก์ชัน one( ) และ two เป็นการบอกว่าไม่มี argument นั่นคือไม่มีการส่งค่าไปนั่นเอง

ข้อสังเกต การประกาศชื่อและชนิดของฟังก์ชันจะต้องประกาศไว้ก่อนฟังก์ชัน main( ) เพราะจะทำให้เราสามารถใช้ฟังก์ชันที่ประกาศไว้ในส่วนใดของโปรแกรมก็ได้

บรรทัดที่ 8 และ 9 คำสั่ง one( ); และ two( ); เป็นการเรียกใช้ฟังก์ชันชื่อ one( ) และ two( ) ตามลำดับ โดยฟังก์ชัน one( ) อยู่ที่คำสั่งบรรทัดที่ 14 ถึง 18 และ ฟังก์ชัน two( ) อยู่ที่บรรทัดที่ 20 ถึง 25

บรรทัดที่ 14 ถึง 18 ฟังก์ชัน one( ) ให้พิมพ์ค่าที่เก็บไว้ในตัวแปร a และ b แสดงที่จอภาพ

บรรทัดที่ 20 ถึง 25 ฟังก์ชัน two( ) ให้พิมพ์ค่าที่เก็บไว้ในตัวแปร p และ q และพิมพ์ค่าตัวแปร q แสดงที่จอภาพ

บรรทัดที่ 10 และ 11 ภายหลังจากทำงานตามฟังก์ชัน one( ) และ two( ) แล้ว พิมพ์ข้อความให้กดคีย์ใด ๆ เพื่อกลับสู่โปรแกรม และหยุดรอรับค่าใด ๆ เช่น กด enter จะกลับเข้าสู่โปรแกรม

เพื่อความเข้าใจเกี่ยวกับการทำงานของฟังก์ชันมากยิ่งขึ้น จากโปรแกรม funct1.c สามารถอธิบายการทำงานได้ดังนี้ (ดูรูปที่ 7.1 ประกอบ)

โปรแกรมหลัก ฟังก์ชัน one( )

ฟังก์ชัน two( )

รูปที่ 7.1 แสดงการทำงานระหว่างโปรแกรมหลักกับฟังก์ชันที่เขียนขึ้น

7.2.3 การเรียกใช้ฟังก์ชัน (calling the function)

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

รูปแบบการใช้ฟังก์ชันในภาษา C

funct_name (argument_list);

โดยที่

funct_name คือ ชื่อฟังก์ชันที่ต้องการใช้งาน

argument_list คือชื่อตัวแปรหรือนิพจน์หรือค่าคงที่ที่ใช้ส่งค่าไป ถ้ามีมากกว่า 1 argument ให้ใช้เครื่องหมาย , (comma) คั่นระหว่าง argument แต่ละค่า เช่น จากตัวอย่างโปรแกรม funct1.c มีคำสั่งที่เรียกใช้ฟังก์ชัน คือ คำสั่ง one( ); และ two( ); ซึ่งอยู่ในโปรแกรมหลักคือฟังก์ชัน main( )

7.2.4 การประกาศรูปแบบฟังก์ชัน (function prototype)

ฟังก์ชันในภาษา C มีลักษณะการใช้งานเหมือนกับตัวแปร ถ้าเราต้องการจะใช้ตัวแปรตัวใดจะต้องประกาศชนิดและชื่อตัวแปรเสียก่อนจึงจะสามารถนำตัวแปรที่ประกาศไว้มาใช้งานได้ ทำนองเดียวกันฟังก์ชันก็เช่นกันจะต้องมีการประกาศชื่อและชนิดของฟังก์ชันเสียก่อน จึงจะสามารถนำมาใช้งานได้

รูปแบบการประกาศฟังก์ชันในภาษา C

type funct_name( type1, type2,….., typeN);

หรือ

type funct_name( type1 arg1, type2 arg2,….., typeN argN);

โดยที่

type คือ ชนิดของค่าข้อมูลที่ส่งกลับมายังฟังก์ชัน ถ้าไม่ระบุจะเป็นชนิด int เสมอ ถ้าไม่มีการส่งค่ากลับให้ใช้คำว่า void

funct_name คือชื่อฟังก์ชัน ซึ่งเราสามารถตั้งชื่อฟังก์ชันโดยใช้กฎเกณฑ์เดียวกันกับการตั้งชื่อตัวแปร

type1, type2,….., typeN คือ ชนิดของ argument ตัวที่ 1, 2, 3,…, N ตามลำดับ

arg1, arg2,….., argN คือ ชื่อ argument ที่ใช้ในการส่งค่าไปตัวที่ 1, 2, 3,…, N ตามลำดับ

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

ตัวอย่างที่ 7.5 แสดงการประกาศรูปแบบฟังก์ชัน

1) float add(int, float);

2) int sum(int p, int q); หรือ int sum(int, int);

3) void move(int, float, int);

4) float calculate(float, float);

5) void point(int*, int*, float); แสดงว่า argumant ตัวที่ 1 และ 2 เป็นตัวแปรพอยน์เตอร์ argument ตัวที่ 3 เป็น float

โปรแกรมตัวอย่างที่ 7.11 แสดงการประกาศรูปแบบของฟังก์ชัน

/* funct2.c */

#include<stdio.h> /* บรรทัดที่ 1 */

#include<conio.h> /* บรรทัดที่ 2 */

int max(int, int); /* บรรทัดที่ 3 */

void main(void) /* บรรทัดที่ 4 */

{ /* บรรทัดที่ 5 */

int p=30, q=45, m; /* บรรทัดที่ 6 */

clrscr(); /* บรรทัดที่ 7 */

m=max(p,q); /* บรรทัดที่ 8 */

printf("Return Maximum Value is...%d",m); /* บรรทัดที่ 9 */

getch(); /* บรรทัดที่ 10 */

} /* end main() */ /* บรรทัดที่ 11 */

/* max() function */ /* บรรทัดที่ 12 */

int max(int a, int b) /* บรรทัดที่ 13 */

{ /* บรรทัดที่ 14 */

return( ( a>b ? a : b ) ); /* บรรทัดที่ 15 */

} /* บรรทัดที่ 16 */

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

คำอธิบายโปรแกรม

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

บรรทัดที่ 3 คำสั่ง int max (int, int); การประกาศรูปแบบฟังก์ชัน

บรรทัดที่ 8 คำสั่ง m = max(p, q); เป็นการเรียกใช้งานฟังก์ชัน max( ) พร้อมทั้งส่งค่า argument ค่าตัวแปร p และ q ไปให้ด้วย ซึ่งภายหลังจากทำงานในฟังก์ชัน max( ) แล้ว ได้ค่าอะไรให้เก็บไว้ที่ตัวแปร m

บรรทัดที่ 13 ถึง 16 เป็นฟังก์ชัน max( ) ซึ่งมีการทำงานคือ สำหรับนิพจน์ (a>b? a : b) ที่อยู่ในฟังก์ชัน return( ) หมายความว่า ถ้าเงื่อนไข a>b เป็นจริง ให้ส่งค่าของตัวแปร a กลับไปยังฟังก์ชันที่เรียกมา แต่ถ้าเงื่อนไข a>b เป็นเท็จ ให้ส่งค่าของตัวแปร b กลับไปยังฟังก์ชันที่เรียกมา

บรรทัดที่ 10 หยุดรอรับค่าใด ๆ เช่น กด enter จะกลับเข้าสู่โปรแกรม

7.2.5 ฟังก์ชันที่ไม่มีทั้งการส่งค่าไปและรับค่ากลับ

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

1) การประกาศฟังก์ชันที่ไม่มีทั้งการส่งค่าไปและรับค่ากลับ

รูปแบบการประกาศฟังก์ชัน

void funct_name(void );

หรือ

void funct_name( );

เช่น void one(void); หรือ void one( ); เป็นต้น

2) โครงสร้างของฟังก์ชันแบบไม่มีทั้งการส่งค่าไปและรับค่ากลับ

รูปแบบโครงสร้างฟังก์ชัน

void funct_name(void);

{

local variable decaration;

statement(s);

}

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

โปรแกรมตัวอย่างที่ 7.12 แสดงการฟังก์ชันที่ไม่มีทั้งการส่งค่าไปและรับค่ากลับ

/* funct3.c */

#include<stdio.h> /* บรรทัดที่ 1 */

#include<conio.h> /* บรรทัดที่ 2 */

void asterisk_line(void); /* บรรทัดที่ 3 */

void main(void) /* บรรทัดที่ 4 */

{ /* บรรทัดที่ 5 */

clrscr( ); /* บรรทัดที่ 6 */

asterisk_line( ); /* บรรทัดที่ 7 */

printf("****** C and C++ PROGRAMMING ******\n"); /* บรรทัดที่ 8 */

asterisk_line(); /* บรรทัดที่ 9 */

printf("\nPress any key back to program ..."); /* บรรทัดที่ 10 */

getch(); /* บรรทัดที่ 11 */

} /* บรรทัดที่ 12 */

/* asterisk_line function */ /* บรรทัดที่ 13 */

void asterisk_line( ) /* บรรทัดที่ 14 */

{ /* บรรทัดที่ 15 */

int j, n=40; /* บรรทัดที่ 16 */

for(j=1; j<=n; j++) /* บรรทัดที่ 17 */

printf("*"); /* บรรทัดที่ 18 */

printf("\n"); /* บรรทัดที่ 19 */

} /* บรรทัดที่ 20 */

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

คำอธิบายโปรแกรม

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

บรรทัดที่ 3 คำสั่ง void asterisk_line (void); แสดงว่าฟังก์ชันชื่อ asterisk_line( ) เป็นฟังก์ชันที่ไม่มีทั้งการส่งค่าไป และรับค่ากลับ

บรรทัดที่ 7 และ 9 เป็นคำสั่งเรียกใช้ฟังก์ชัน asterisk_line( ) ซึ่งฟังก์ชันอยู่คำสั่งบรรทัดที่ 14 ถึง 19

บรรทัดที่ 14 ถึง 19 ฟังก์ชัน asterisk_line( ) มีการทำงานโดยพิมพ์ * จำนวน 40 ตัวออกแสดงที่จอภาพ

7.2.6 ฟังก์ชันที่มีการส่งค่าไปแต่ไม่มีการรับค่ากลับ

การประกาศฟังก์ชันชนิดนี้ มีชนิดเป็น void แต่ภายในเครื่องหมาย ( ) จะมีชนิดของ argument ปรากฏอยู่ตามปกติ ส่วนโครงสร้างของฟังก์ชันชนิดนี้จะไม่มีคำสั่ง return(value);

1) การประกาศฟังก์ชันที่มีการส่งค่าไปแต่ไม่มีการรับค่ากลับ

รูปแบบการประกาศฟังก์ชัน

void funct_name(type1, type2,….., typeN);

หรือ

void funct_name( type1 arg1, type2 arg2,….., typeN argN);

ตัวอย่างที่ 7.6 แสดงการประกาศฟังก์ชัน

void multiply(int, int);

void add(float, int);

void a(int*, int);

2) โครงสร้างของฟังก์ชันที่มีการส่งค่าไปแต่ไม่มีการรับค่ากลับ

รูปแบบโครงสร้างฟังก์ชัน

void funct_name( type1 arg1, type2 arg2,….., typeN argN);

{

local variable declaration;

statement(s);

}

เพื่อความเข้าใจเกี่ยวกับการใช้ฟังก์ชันที่มีการส่งค่าไปแต่ไม่มีการรับค่ากลับ มากยิ่งขึ้น ให้ศึกษาจากโปรแกรมตัวอย่าง 7.13 และ 7.14 ต่อไปนี้

โปรแกรมตัวอย่างที่ 7.13 แสดงฟังก์ชันที่มีทั้งการส่งค่าไปแต่ไม่มีการรับค่ากลับ โดยการส่งค่าตัวเลขไปยังฟังก์ชัน

/* pvalue.c */

/* pass value to function */

#include<stdio.h> /* บรรทัดที่ 1 */

#include<conio.h> /* บรรทัดที่ 2 */

void add(int, int); /* บรรทัดที่ 3 */

void subtract(float, float); /* บรรทัดที่ 4 */

void multiply(int, float); /* บรรทัดที่ 5 */

void divide(float, int); /* บรรทัดที่ 6 */

void main(void) /* บรรทัดที่ 7 */

{ /* บรรทัดที่ 8 */

int x=3, y=5; /* บรรทัดที่ 9 */

float z=6.5; /* บรรทัดที่ 10 */

clrscr( ); /* บรรทัดที่ 11 */

add(x,y); /* called add */ /* บรรทัดที่ 12 */

subtract(z, z+4.5); /*called subtract */ /* บรรทัดที่ 13 */

multiply(y,z); /*called multiply */ /* บรรทัดที่ 14 */

divide(z+11.5, x); /*called divide */ /* บรรทัดที่ 15 */

printf("\nPress any key back to program ..."); /* บรรทัดที่ 16 */

getch(); /* บรรทัดที่ 17 */

} /* end main() */ /* บรรทัดที่ 18 */

/* add function */ /* บรรทัดที่ 19 */

void add(int p, int q) /* บรรทัดที่ 20 */

{ /* บรรทัดที่ 21 */

int k; /* บรรทัดที่ 22 */

k=p+q; /* บรรทัดที่ 23 */

printf("P = %d \tQ = %d \tK = %d\n",p,q,k); /* บรรทัดที่ 24 */

} /* บรรทัดที่ 25 */

/* subtract function */ /* บรรทัดที่ 26 */

void subtract(float p, float q) /* บรรทัดที่ 27 */

{ /* บรรทัดที่ 28 */

float k; /* บรรทัดที่ 29 */

k=q-p; /* บรรทัดที่ 30 */

printf("P = %.3f \tQ = %.3f \tK = %.3f\n",p,q,k); /* บรรทัดที่ 31 */

} /* บรรทัดที่ 32 */

/* multiply function */ /* บรรทัดที่ 33 */

void multiply(int p, float q) /* บรรทัดที่ 34 */

{ /* บรรทัดที่ 35 */

float k; /* บรรทัดที่ 36 */

k=p*q; /* บรรทัดที่ 37 */

printf("P = %d \tQ = %.3f \tK=%.3f\n",p,q,k); /* บรรทัดที่ 38 */

} /* บรรทัดที่ 39 */

/* divide function */ /* บรรทัดที่ 40 */

void divide(float p, int q) /* บรรทัดที่ 41 */

{ /* บรรทัดที่ 42 */

float k; /* บรรทัดที่ 43 */

k=p/q; /* บรรทัดที่ 44 */

printf("P = %.3f \tQ = %d \tK = %.3f\n",p,q,k); /* บรรทัดที่ 45 */

} /* บรรทัดที่ 46 */

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

คำอธิบายโปรแกรม

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

บรรทัดที่ 3 ประกาศฟังก์ชันที่มีการส่งค่า int ไป แต่ไม่มีการรับค่ากลับ ชื่อฟังก์ชัน add( )

บรรทัดที่ 4 ประกาศฟังก์ชันที่มีการส่งค่า float ไป แต่ไม่มีการรับค่ากลับ ชื่อฟังก์ชัน subtract( )

บรรทัดที่ 5 ประกาศฟังก์ชันที่มีการส่งค่า int และ float ไป แต่ไม่มีการรับค่ากลับ ชื่อฟังก์ชัน multiply( )

บรรทัดที่ 6 ประกาศฟังก์ชันที่มีการส่งค่า float และ int ไป แต่ไม่มีการรับค่ากลับ ชื่อฟังก์ชัน divide( )

บรรทัดที่ 12 เรียกใช้ฟังก์ชัน add( ) โดยส่งค่าตัวแปร x และ y ที่เป็น int ไป ซึ่งการทำงานของฟังก์ชันจะอยู่บรรทัดที่ 20 ถึง 25

บรรทัดที่ 13 เรียกใช้ฟังก์ชัน subtract( ) โดยส่งค่าตัวแปร z และ z + 4.5 ที่เป็น float ไป ซึ่งการทำงานของฟังก์ชันจะอยู่บรรทัดที่ 27 ถึง 32

บรรทัดที่ 14 เรียกใช้ฟังก์ชัน multiply( ) โดยส่งค่าตัวแปร y และ z ที่เป็น int และ float ไป ซึ่งการทำงานของฟังก์ชันจะอยู่บรรทัดที่ 34 ถึง 39

บรรทัดที่ 15 เรียกใช้ฟังก์ชัน divide( ) โดยส่งค่าตัวแปร z + 11.5 และ x ที่เป็น float และ int ไป ซึ่งการทำงานของฟังก์ชันจะอยู่บรรทัดที่ 41 ถึง 46

บรรทัดที่ 20 ถึง 25 เป็นการทำงานของฟังก์ชัน add( ) โดยบวกตัวเลข และแสดงผลออกจอภาพ

บรรทัดที่ 27 ถึง 32 เป็นการทำงานของฟังก์ชัน subtract( ) โดยลบตัวเลข และ แสดงผลออกจอภาพ

บรรทัดที่ 34 ถึง 39 เป็นการทำงานของฟังก์ชัน multiply( ) โดยคูณตัวเลข และ แสดงผลออกจอภาพ

บรรทัดที่ 41 ถึง 46 เป็นการทำงานของฟังก์ชัน divide( ) โดยหารตัวเลข และ แสดงผลออกจอภาพ

บรรทัดที่ 16 และ 17 พิมพ์ข้อความให้กดคีย์ใด ๆ เพื่อกลับสู่โปรแกรม และหยุดรอรับค่าใด ๆ เช่น กด enter จะกลับเข้าสู่โปรแกรม

โปรแกรมตัวอย่างที่ 7.14 แสดงการส่งค่า address ของตัวแปรชุดไปยังฟังก์ชันที่มีการส่งค่าไปแต่ไม่มีการรับค่ากลับ

/* padd.c */

/* pass address of array to function */

#include<stdio.h> /* บรรทัดที่ 1 */

#include<conio.h> /* บรรทัดที่ 2 */

void address(int *); /* บรรทัดที่ 3 */

void main(void) /* บรรทัดที่ 4 */

{ /* บรรทัดที่ 5 */

int array[5]= {100, 200, 300, 400, 500 }; /* บรรทัดที่ 6 */

clrscr( ); /* บรรทัดที่ 7 */

address(array); /* บรรทัดที่ 8 */

printf("\nPress any key back to program ..."); /* บรรทัดที่ 9 */

getch(); /* บรรทัดที่ 10 */

} /* end main() */ /* บรรทัดที่ 11 */

/* address function */ /* บรรทัดที่ 12 */

void address(int *ptr) /* บรรทัดที่ 13 */

{ /* บรรทัดที่ 14 */

int j; /* บรรทัดที่ 15 */

for(j=0; j<5; j++) /* บรรทัดที่ 16 */

printf( "Array#%d = %d\n",j+1, *(ptr+j) ); /* บรรทัดที่ 17 */

} /* บรรทัดที่ 18 */

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

คำอธิบายโปรแกรม

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

บรรทัดที่ 3 คำสั่ง void address(int*); เป็นการประกาศรูปแบบฟังก์ชันที่มีการส่งค่าไปเป็นชนิด int* แต่ไม่มีการส่งค่ากลับ ซึ่งฟังก์ชันชื่อ address( )

บรรทัดที่ 8 คำสั่ง address(array); เป็นการเรียกใช้ฟังก์ชัน address( ) โดยส่งค่าตัวแปร array ไปให้ฟังก์ชัน ซึ่งฟังก์ชัน array อยู่คำสั่งบรรทัดที่ 13 ถึง 18

บรรทัดที่ 13 ถึง 18 ฟังก์ชัน address( ) รับค่าของ array มาแสดงผลออกจอภาพ โดยใช้คำสั่ง for วนลูปช่วยในการเข้าถึงข้อมูลใน array

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

7.2.7 ฟังก์ชันที่มีทั้งการส่งค่าไปและรับค่ากลับ

ฟังก์ชันชนิดนี้เป็นฟังก์ชันที่ต้องมีชนิดและ argument ของฟังก์ชันส่วนในโครงสร้างของฟังก์ชันชนิดนี้จะต้องมีคำสั่ง return(value); เพื่อส่งค่ากลับด้วย ยกเว้นในกรณีที่ใช้ตัวแปรพอยน์เตอร์ (pointer) มาช่วยไม่ต้องมีคำสั่ง return(value); ก็ได้

1) การประกาศฟังก์ชันที่มีทั้งการส่งค่าไปและรับค่ากลับ

รูปแบบการประกาศฟังก์ชัน

type funct_name( type1, type2,….., typeN);

หรือ

type funct_name( type1 arg1, type2 arg2,….., typeN argN);

ตัวอย่างที่ 7.7 แสดงการประกาศฟังก์ชัน

int multiply(int, int);

float add(float, int);

int a(int*, int);

2) โครงสร้างของฟังก์ชันที่มีทั้งการส่งค่าไปและรับค่ากลับ

รูปแบบโครงสร้างของฟังก์ชัน

type funct_name( type1 arg1, type2 arg2,….., typeN argN);

{

local variable declaration;

statement(s);

return(value);

}

เพื่อความเข้าใจเกี่ยวกับการใช้ฟังก์ชันที่มีทั้งการส่งค่าไปและรับค่ากลับมากยิ่งขึ้น ให้ศึกษาจากโปรแกรมตัวอย่าง 7.15 ถึง 7.17 ต่อไปนี้

โปรแกรมตัวอย่างที่ 7.15 แสดงการใช้งานฟังก์ชันที่มีทั้งการส่งค่าไปและรับค่ากลับที่มี argument เป็น int

/* rvaluef.c */

/* pass and return value function */

#include<stdio.h> /* บรรทัดที่ 1 */

#include<conio.h> /* บรรทัดที่ 2 */

int calculate(int, int); /* บรรทัดที่ 3 */

void main(void) /* บรรทัดที่ 4 */

{ /* บรรทัดที่ 5 */

int p=3, q=4, r; /* บรรทัดที่ 6 */

clrscr( ); /* บรรทัดที่ 7 */

r = calculate(p,q); /* บรรทัดที่ 8 */

printf("P = %d, Q = %d, R = %d\n",p,q,r); /* บรรทัดที่ 9 */

printf("\nPress any key back to program ..."); /* บรรทัดที่ 10 */

getch(); /* บรรทัดที่ 11 */

} /* end main() */ /* บรรทัดที่ 12 */

int calculate(int p, int q) /* บรรทัดที่ 13 */

{ /* บรรทัดที่ 14 */

return (p+q); /* บรรทัดที่ 15 */

} /* บรรทัดที่ 16 */

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

คำอธิบายโปรแกรม

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

บรรทัดที่ 3 คำสั่ง int calculate (int, int); การประกาศรูปแบบฟังก์ชันที่มีการส่งค่า argument ไป 2 ตัว ชนิด int และ มีการส่งค่ากลับมายังฟังก์ชันเป็นชนิด int เช่นกัน โดยฟังก์ชันชื่อ caculate( )

บรรทัดที่ 8 คำสั่ง r = caculate (p, q); เป็นการเรียกใช้ฟังก์ชัน caculate( ) และส่งค่า p และ q ส่งไปให้ฟังก์ชันด้วย ตามลำดับ ซึ่งฟังก์ชัน caculate( ) อยู่คำสั่งบรรทัดที่ 13 ถึง 16

บรรทัดที่ 13 ถึง 16 ฟังก์ชัน caculate( ) โดยมีการทำงาน คือ นำค่าตัวแปร p และ q ที่ได้มาบวกกัน แล้วส่งผลลัพธ์ที่ได้กลับไปให้ ณ จุดที่เรียกใช้ในฟังก์ชัน main( ) นั่นคือ ไปเก็บไว้ที่ตัวแปร r

บรรทัดที่ 9 แสดงค่าตัวแปร p, q และ r แสดงที่จอภาพ

โปรแกรมตัวอย่างที่ 7.16 แสดงการใช้งานฟังก์ชันที่มีทั้งการส่งค่าไปและรับค่ากลับที่มี argument เป็นพอยน์เตอร์

/* cref.c */

/* call by address to function and return value */

#include<stdio.h> /* บรรทัดที่ 1 */

#include<conio.h> /* บรรทัดที่ 2 */

int change(int *, int *); /* บรรทัดที่ 3 */

void main(void) /* บรรทัดที่ 4 */

{ /* บรรทัดที่ 5 */

int p=50, q=100; /* บรรทัดที่ 6 */

clrscr( ); /* บรรทัดที่ 7 */

printf("P = %d, Q = %d\n",p,q); /* บรรทัดที่ 8 */

change(&p,&q); /* บรรทัดที่ 9 */

printf("P = %d, Q = %d\n",p,q); /* บรรทัดที่ 10 */

change(&p,&q); /* บรรทัดที่ 11 */

printf("P = %d, Q = %d\n",p,q); /* บรรทัดที่ 12 */

printf("\nPress any key back to program ..."); /* บรรทัดที่ 13 */

getch(); /* บรรทัดที่ 14 */

} /* บรรทัดที่ 15 */

int change(int *ptr_p, int *ptr_q) /* บรรทัดที่ 16 */

{ /* บรรทัดที่ 17 */

int tempo; /* บรรทัดที่ 18 */

tempo = *ptr_p; /* บรรทัดที่ 19 */

*ptr_p = *ptr_q; /* บรรทัดที่ 20 */

*ptr_q = tempo; /* บรรทัดที่ 21 */

} /* บรรทัดที่ 22 */

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

คำอธิบายโปรแกรม

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

บรรทัดที่ 3 คำสั่ง int change (int*, int*); การประกาศรูปแบบฟังก์ชันที่มีการส่งค่า ของตัวแปร 2 ตัวที่เป็นพอยน์เตอร์ และมีการส่งค่ากลับมายังฟังก์ชัน โดยฟังก์ชันชื่อ change( )

บรรทัดที่ 8 แสดงค่าตัวแปร p และ q ออกที่จอภาพ คือ p = 50 และ q = 100

บรรทัดที่ 9 คำสั่ง change (&p, &q); คำสั่งเรียกใช้ฟังก์ชัน change( ) โดยส่งค่า address ของ p และ q ไปยังฟังก์ชัน change( ) ด้วย ตามลำดับ ซึ่งฟังก์ชัน change( ) อยู่คำสั่งบรรทัดที่ 16 ถึง 22

บรรทัดที่ 16 ถึง 22 ฟังก์ชัน change( ) มีการทำงานโดยใช้ตัวแปรพอยเตอร์ในการสลับค่าตัวแปร p และ q ดังนั้น p = 100 และ q = 50

บรรทัดที่ 10 แสดงค่าตัวแปร p และ q ภายหลังจากที่สลับค่ากันแล้ว แสดงออกจอภาพ

บรรทัดที่ 11 ทำงานเหมือนคำสั่งบรรทัดที่ 9 ดังนั้น ภายหลังจากสลับค่ากันแล้ว จะได้ p = 50, q = 100

บรรทัดที่ 12 แสดงค่าตัวแปร p และ q ภายหลังจากที่สลับค่ากันอีกครั้ง แสดงออกจอภาพ

โปรแกรมตัวอย่างที่ 7.17 แสดงการใช้งานฟังก์ชันที่มีทั้งการส่งค่าไปและรับค่ากลับ มี argument เป็นพอยน์เตอร์ 3 ตัว

/* calcu.c */

#include<stdio.h> /* บรรทัดที่ 1 */

#include<conio.h> /* บรรทัดที่ 2 */

void calcu(int *, int *, int *); /* บรรทัดที่ 3 */

void main(void) /* บรรทัดที่ 4 */

{ /* บรรทัดที่ 5 */

int a=3, b=10, c=5; /* บรรทัดที่ 6 */

clrscr( ); /* บรรทัดที่ 7 */

calcu(&a, &b, &c); /* บรรทัดที่ 8 */

printf("A = %d, B = %d, C = %d\n",a,b,c); /* บรรทัดที่ 9 */

printf("\nPress any key back to program ..."); /* บรรทัดที่ 10 */

getch(); /* บรรทัดที่ 11 */

} /* บรรทัดที่ 12 */

void calcu(int *pa, int *pb, int *pc) /* บรรทัดที่ 13 */

{ /* บรรทัดที่ 14 */

*pa = *pa * 5; /* บรรทัดที่ 15 */

*pb = *pb + 10; /* บรรทัดที่ 16 */

*pc = *pc + *pb; /* บรรทัดที่ 17 */

} /* บรรทัดที่ 18 */

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

คำอธิบายโปรแกรม

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

บรรทัดที่ 3 คำสั่ง void calcu(int*, int*, int*); ประกาศตัวรูปแบบฟังก์ชันที่มีการส่งค่า address ของตัวแปร 3 ตัวที่เป็นพอยน์เตอร์ ฟังก์ชันชื่อ calcu( )

บรรทัดที่ 8 คำสั่ง calcu(&a, &b, &c); คำสั่งที่มีการเรียกใช้ฟังก์ชัน calcu( ) โดยส่งค่า address ของ a, b และ c ไปยังฟังก์ชัน calcu( ) ตามลำดับ ฟังก์ชัน calcu( ) อยู่คำสั่งบรรทัดที่ 13 ถึง 18

บรรทัดที่ 13 ถึง 18 ฟังก์ชัน calcu( ) จะใช้ตัวแปรพอยเตอร์ในการคำนวณค่าของตัวแปรใหม่ โดย จะได้

ค่าของ a ที่ตัวแปรพอยเตอร์ *pa ชี้อยู่ เป็น 3 * 5 = 15

ค่าของ b ที่ตัวแปรพอยเตอร์ *pb ชี้อยู่ เป็น 10 + 10 = 20

ค่าของ c ที่ตัวแปรพอยเตอร์ *pc ชี้อยู่ เป็น 5 + 20 = 25

บรรทัดที่ 9 แสดงค่าตัวแปร a, b และ c ออกที่จอภาพ

7.3 สรุปท้ายบท

ฟังก์ชันในภาษา C ที่กล่าวถึงมี 2 ประเภทหลัก ๆ ดังนี้

1. ฟังก์ชันมาตรฐาน (standard functions) เป็นฟังก์ชันที่บริษัทที่ผลิตภาษา C ได้เขียนขึ้นและเก็บไว้ใน header file ภาษา C คือเก็บไว้ในแฟ้มที่มีนามสกุล *.h ต่าง ๆ ฟังก์ชันมาตรฐานที่สำคัญ ๆ มีดังนี้

1.1 ฟังก์ชันทางคณิตศาสตร์ (mathematic functions) เป็นฟังก์ชันที่ใช้สำหรับการคำนวณทางคณิตศาสตร์ และก่อนที่จะใช้ฟังก์ชันประเภทนี้ จะต้องใช้คำสั่ง #include <math.h> แทรกอยู่ตอนต้นของโปรแกรม และตัวแปรที่จะใช้ฟังก์ชันประเภทนี้จะต้องมีชนิด (type) เป็น double เนื่องจากผลลัพธ์ที่ได้จากฟังก์ชันประเภทนี้จะได้ค่าส่งกลับของข้อมูลเป็น double เช่นกัน ฟังก์ชันทางคณิตศาสตร์ที่สำคัญ เช่น

ฟังก์ชัน acos(x) เป็นฟังก์ชันที่ใช้คำนวณหาค่า arc cosine ของ x โดยที่ x เป็นค่ามุมในหน่วยเรเดียน (radian)

ฟังก์ชัน exp(x) เป็นฟังก์ชันที่ใช้หาค่า ex โดยที่ x เป็นค่าคงที่หรือตัวแปรที่จะใช้เป็นค่ายกกำลังของ e โดยที่ e มีค่าประมาณ 2.718282

ฟังก์ชัน log10(x) เป็นฟังก์ชันที่ใช้หาค่า log ฐาน 10 ของค่าคงที่หรือตัวแปร x โดยที่ x เป็นค่าคงที่หรือตัวแปรที่มีค่าเป็นลบไม่ได้

1.2 ฟังก์ชันเกี่ยวกับตัวอักษร (character functions) เป็นฟังก์ชันที่ใช้กับข้อมูลที่มีชนิดเป็น single char (ใช้เนื้อที่ 1 byte) เท่านั้น และก่อนที่จะใช้ฟังก์ชันประเภทนี้จะต้องใช้คำสั่ง #include<ctype.h> แทรกอยู่ตอนต้นของโปรแกรม จึงจะสามารถเรียกใช้ฟังก์ชันประเภทนี้ได้ ฟังก์ชันเกี่ยวกับตัวอักษรที่สำคัญ เช่น isalnum(ch), isalpha(ch), isdigit(ch), islower(ch), isupper(ch), tolower(ch), toupper(ch),

isspace(ch), isxdigit(ch)

1.3 ฟังก์ชันเกี่ยวกับสตริง (string functions) เป็นฟังก์ชันที่ใช้กับข้อมูลชนิดสตริง (string) โดยก่อนที่จะใช้ฟังก์ชันประเภทนี้จะต้องใช้คำสั่ง #include<string.h> แทรกอยู่ตอนต้นของโปรแกรมเสียก่อน จึงจะเรียกใช้ฟังก์ชันประเภทนี้ได้ ฟังก์ชันเกี่ยวกับสตริงที่สำคัญ เช่น strlen(s), strcmp(s1,s2), strcpy(s), strcat(s1,s2)

1.4 ฟังก์ชันทั่วไปที่ใช้งานบ่อย ๆ เช่น

ฟังก์ชัน clrscr( ) เป็นฟังก์ชันที่ใช้ในการลบข้อมูลออกจากจอภาพแบบ text mode

ฟังก์ชัน gotoxy(x,y) เป็นฟังก์ชันที่ใช้คำสั่งให้ตัวชี้ตำแหน่ง (cursor) เคลื่อนที่ไปยังตำแหน่งที่ระบุไว้บนจอภาพ

ฟังก์ชัน sizeof(x) เป็นฟังก์ชันที่ใช้ตรวจสอบขนาดของตัวแปร x ว่ามีขนาดกี่ Byte

2. ฟังก์ชันที่เขียนขึ้น (user defined functions) ฟังก์ชันที่เขียนขึ้นหรือบางครั้งเราเรียกว่าโปรแกรมย่อย คือ ส่วนของโปรแกรมที่เขียนขึ้นเพื่อให้สามารถทำงานได้อย่างใดอย่างหนึ่งตามความต้องการ สำหรับผู้เขียนโปรแกรมภาษา C นิยมเรียกโปรแกรมย่อยว่า ”ฟังก์ชัน” ส่วนผู้ที่เขียนโปรแกรมภาษาปาสคาล โคบอล ฟอร์แทรน เบสิก นิยมเรียกว่า ”โปรแกรมย่อย” อย่างไรก็ตามโปรแกรมย่อยหรือฟังก์ชันก็มีลักษณะการทำงานเหมือนกันเพียงแต่เรียกชื่อต่างกันเท่านั้นสำหรับในเอกสารนี้จะเรียกว่า ฟังก์ชัน ซึ่งในเนื้อหาส่วนนี้จะเป็นการเรียนรู้เกี่ยวกับฟังชันที่เขียนขึ้น (user define functions : UDF) ตั้งแต่การประกาศรูปแบบฟังก์ชัน การเขียนตัวฟังก์ชันและการเรียกใช้ฟังก์ชันเพื่อให้สามารถใช้ฟังก์ชันที่เขียนขึ้นในโปรแกรมภาษา C ได้อย่างถูกต้อง

2.1 ฟังก์ชันที่ไม่มีการส่งค่าไปและรับค่ากลับ

2.2 ฟังก์ชันที่มีการส่งค่าไปแต่ไม่มีรับค่ากลับ

2.3 ฟังก์ชันที่มีทั้งการส่งค่าไปและรับค่ากลับ

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