กลุ่ม 6

1. โปรแกรมย่อยและ
ฟังก์ชันมาตรฐาน

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

3. โปรแกรมย่อย
• การวางตาแหน่งโปรแกรมย่อย ภาษาซีมีเลือกให้ใช้งาน 2 ลักษณะคือ
1. วางโปรแกรมย่อยไว้ในตาแหน่งก่อนส่วนโปรแกรม
2. วางโปรแกรมย่อยไว้ในตาแหน่งหลังส่วนโปรแกรมหลัก

4. โปรแกรมย่อย
1.วางโปรแกรมย่อยไว้ในตาแหน่ง 2.วางโปรแกรมย่อยไว้ในตาแหน่ง
ก่อนส่วนโปรแกรม หลังส่วนโปรแกรมหลัก
#include <stdio.h> #include
<stdio.h>
Main () Main ()
{ {
Function-name2 () ;
Function-name1 () ;
…………………
Function-name2 () ;
Function-name1 () ;

5. • ข้อแนะนาในการเขียนโปรแกรมย่อย
กรณีเลือกวางโปรแกรมย่อยไว้หลังโปรแกรมหลัก ต้อง
ประกาศชื่อโปรแกรมย่อยต่อจาก #include เสมอ มิฉะนั้นจะ
เกิดข้อผิดพลาดได้
กรณีมีโปรแกรมย่อยหลายส่วนงาน วางโปรแกรมย่อยไว้
หลังโปรแกรมหลัก เพราะหลักการอ่านคาสั่งงานจะต้องอ่านในส่วน
โปรแกรมหลักก่อน แล้วจึงโยงไปที่โปรแกรมย่อย หากมีโปรแกรม
ย่อยจานวนมากจะดันโปรแกรมหลักไปอยู่ส่วนล่าง ทาให้เสียเวลา
ค้นหาโปรแกรมหลัก
โปรแกรมย่อย

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

7. ตัวอย่างโปรแกรมย่อยแบบไม่มีการรับส่งค่าพารามิเตอร์
#include<stdio.h>
#include<conio.h>
void asterisk_line(void);
void main(void)
{
Clrscr( );
asterisk_line( );
printf(“******C and C++
PROGRAMMING******n”);
asterisk_line( );
printf(“nPress any key back to
program…”);
โปรแกรมย่อย
โปรแกรม
Getch();
}
/*asterisk_line function*/
void asterisk_line( )
{
int j, n=40;
for( j=1; j<n; j++)
printf(“*”);
printf(“n”);
}

8. • คำอธิบำยโปรมแกรม
จากโปรมแกรมสามารถอธิบายการทางานของโปรแกรมที่สาคัญๆ ได้ดังนี้
บรรทัดที่3 คาสั่ง void asterisk_line(void); แสดงว่าฟังก์ชันชื่อ asterisk_line( )
เป็นฟังก์ชันที่ไม่มีทั้งการส่งค่าไป และรับค่ากลับ
บรรทัดที่7 และ9 เป็นคาสั่งเรียกใช้ฟังก์ชัน asterisk_line( ) ซึ่งฟังก์ชันอยู่บรรทัดที่14
ถึง19
บรรทัดที่14 ถึง19 ฟังก์ชัน asterisk_line( ) มีการทางานโดยพิมพ์* จานวน 40 ตัว
ออกแสดงที่จอภาพ
บรรทัดที่10 และ11 พิมพ์ข้อความให้กดคีย์ใดๆ เพื่อกลับสู่โปรแกรม และหยุดรอรับคา ใดๆ เช่น
กด enter จะกลับสู่โปรแกรม
โปรแกรมย่อย

9. • โปรแกรมย่อยแบบรับค่ำพำรำมิเตอร์ไปใช้อย่ำงเดียว
โปรแกรมย่อยลักษณะนี้มีจุดประสงค์เพื่อแบ่งระบบงานให้เป็นโปรแกรมย่อย และต้องการให้
โปรแกรมย่อยมีประสิทธิภาพรับค่าข้อมูลจากโปรแกรมหลักที่ส่งไปให้ใช้ในการประมวลผลภายในโปรแกรม
ย่อยได้ ดังนั้นการเรียกชื่อโปรแกรมย่อยต้องตามด้วยค่าข้อมูลที่ส่งไปให้ใช้งานด้วย
การกาหนดคุณสมบัติให้โปรแกรมย่อยทางานในลักษณะรับค่าพารามิเตอร์ไปใช้ เขียนรูปแบบ
ได้ดังนี้
รูปแบบ
void function_name(type_parameter_name{…};
โปรแกรมย่อย

10. • กำหนดคุณสมบัติให้โปรแกรมย่อยทำงำนในลักษณะรับค่ำพำรำมิเตอร์ไปใช้
#include <stdio.h>
Void addition ( int , int );
Void main ( )
{
Int a,b;
………………………….
Addition (a,b);
}
Void addition (int m, int n)
{
………………………….
}
โปรแกรมย่อย

11. • โปรแกรมย่อยแบบรับและคืนค่ำพำรำมิเตอร์
จุดประสงค์แบ่งโปรแกรมเป็นโปรแกรมส่วนย่อย และให้โปรแกรมย่อยมีประสิทธิภาพรับค่าข้อมูลจาก
โปรแกรมหลัก ไปใช้ในการประมวลภายในโปรแกรมย่อย รวมทั้งสามารถส่งค่าที่ได้จากการประมวลผลกลับไปที่
โปรแกรมหลัก
• โปรแกรมย่อยประเภทนี้ ประกาศลักษณะการทางานด้วยรูปแบบดังนี้
รูปแบบ Type_variable function_name(parameter_name)
Type_variable ชื่อชนิดข้อมูลของตัวแปร ที่ส่งกลับมาจากโปรแกรมย่อย
function_name ชื่อโปรแกรม
parameter_name ชื่อพารามิเตอร์ที่รับค่ามาใช้งานในโปรแกรม หากมีมากกว่า
1 ใช้ , คั่น
โปรแกรมย่อย

12. • โครงสร้ำงของโปรแกรม
โปรแกรมย่อย

13. • ตัวอย่ำงคำสั่ง กาหนดให้โปรแกรมย่อยรับคาพารามิเตอร์จากโปรแกรมหลักไปใช้ และคาสั่งกลับมาให้ได้
#include<stdio.h>
#include<conio.h>
Int calculate(int, int);
Void main(void)
{
โปรแกรม
Int p=3, q=4, r;
Clrscr( );
r = calculate(p,q);
printf(“P = %d, Q = %d, R = %dn” ,p,q,r);
printf(“nPress any key back to program …”);
getch();
} /* end main() */
Int calculate(int p, int q)
{
Return (p+q);
}
โปรแกรมย่อย

14. • คำอธิบำยโปรแกรม
จากโปรแกรม สามารถอธิบายการทางานของโปรแกรมที่สาคัญๆ ได้ดังนี้
บรรทัดที่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 แสดงที่จอภาพ
บรรทัดที่10 และ 11 พิมพ์ข้อความให้กดคีย์ใดๆ เพื่อกลับสู่โปรแกรม และหยุดรอ
รับค่าใดๆ เช่น กด enter จะกลับเข้าสู่โปรแกรม
โปรแกรมย่อย

15. • ฟังก์ชันที่ไม่มีกำรรับค่ำพำรำมิเตอร์แต่มีกำรส่งคืนค่ำ
มีการเรียกใช้ดังนี้ variable_name =function_name ( );
โดย variable_name คือชื่อของตัวแปรที่จะมารับค่าของฟังก์ชันที่ส่งคืนมา
ฟังก์ชันประเภทนี้ต้องมีชนิดของฟังก์ชัน แต่ไม่มีพารามิเตอร์ และในโครงสร้างต้องมีคาสั่ง
return(value) เพื่อส่งค่ากลับ
โปรแกรมย่อย

16. • ประสิทธิภำพกำรทำงำนของตัวแปร
ตัวแปรที่ประกาศการใช้งานในตาแหน่งของโครงสร้างตัวซีในตาแหน่งที่ต่างกัน ย่อมมีประสิทธิภาพการ
ทางานที่แตกต่างกันไปคือ ตัวแปรที่ประกาศการใช้งานตัวนอกส่วนของโปรแกรมใดๆ มีประสิทธิภาพการการใช้งาน
ต่างกันกับตัวแปรภายในโปรแกรมหลัก
ตัวแปรภายใน (Local Variable) คือ ตัวแปรที่ถูกสร้างขึ้นภายในฟังก์ชัน สามารถเรียกใช้งานได้
เฉพาะภายในฟังก์ชันที่สร้างขึ้น และถูกทาลายลงเมื่อเสร็จสิ้นการทางานของฟังก์ชันนั้นๆ
ตัวแปรภายนอก (Global Variable) คือ ตัวแปรที่ถูกสร้างขึ้นภายนอกฟังก์ชัน สามารถใช้งานได้
ในทุกฟังก์ชัน หรือทั้งโปรแกรม (ยกเว้นฟังก์ชันที่มีตัวแปรภายในชื่อเดียวกับโปรแกรมภายนอก ซึ่งมีความเป็นไปได้)
และจะคงอยู่ตลอดการทางานของโปรแกรม
โปรแกรมย่อย

17. • โปรแกรมตัวอย่ำง
/* 7^th sample program: Local vs Global Variable */
include<stdio.h>
int ans =o;
into inc_one(into); /* function prototype*/
void main()
{
int a = 3;
ans = inc_one(a);
printf("Answer is %dn",ans);
}
/*function defenition: return X+1*/
int inc_one(int x)
{
int ans;
ans = X+1;
return ans ;
}
โปรแกรมย่อย

18. • ข้อสังเกต
สังเกตง่ายที่สุดคือตัวแปรภายนอก ans เพราะถูกประกาศเอาไว้ภายนอกฟังก์ชัน โดยสามารถเรียกใช้งานได้โดย
ฟังก์ชันหลัก (main) หรือฟังก์ชันใดๆ สังเกตได้ว่าฟังก์ชันหลัก ใช้ตัวแปร ans โดยไม่มีการประกาศตัวแปร
หากจะระบุว่าตัวแปรใดเป็นตัวแปรภายใน จะต้องพิจารณาทีละฟังก์ชัน ในฟังก์ชันหลักตัวแปร a คือ ตัวแปรภายใน
เพราะถูกประกาศไว้ในฟังก์ชันหลัก
ในฟังก์ชัน inc_one มีตัวแปร x และ ans เป็นตัวแปรใน ข้อสังเกตเพิ่มเติมคือ ans ที่ประกาศขึ้นในฟังก์ชันนี้
มีชื่อเหมือนกับ ans ทีเป็นตัวแปรภายนอกของโปแกรม อย่างไรก็ตามหากลองย้อนกลับไปดูนิยามก็จะพบว่าสามารถทาได้ เพียงแต่
ว่าในฟังก์ชัน inc_one ได้ประกาศตัวแปร ans ซึ่งเป็นตัวแปรภายใน ใช้งานในฟังก์ชัน inc_one เท่านั้นโดยไม่เกี่ยวกับตัว
แปร ans ซึ่งเป็นตัวแปรภายนอก หากฟังก์ชัน inc_one ไม่ได้ประกาศตัวแปร ans ขึ้นใหม่ก็จะมาสามรถเรียกใช้ตัวแปร ans
ซึ่งเป็นตัวแปรภายนอกได้เช่นเดียวกับฟังก์ชันหลัก
โปรแกรมย่อย

19. • ตัวอย่างแสดงโกลบอลและโลคอล
PROGRAM AA;
VAR NUM:INTEGER;
PROCEDURE A;
BEGIN
NUM:=NUM*10;
WRITELN(‘NUM*10 = ‘,NUM);
END;
VAR ANY:INTEGER;
PROCEDURE B;
VAR NUM,CNTR:INTEGER;
BEGIN
NUM:=124;
WRITELN(‘NUM = ‘,NUM);
CNTR:=122;
WRITELN(‘CNTR =’,CNTR);
END;
BEGIN {MAIN PROGRAM}
NUM:=5;
WRITELN(‘IN MAIN’,’NUM = ‘,NUM);
A;
B;
WRITELN(‘BACK TO MAIN NUM = ‘,NUM);
END.
โปรแกรมย่อย

20. • คำอธิบำย
-NUM ที่กาหนดในโปรแกรมหลักเป็นโกบอล คือค่าและoutput ในโปรแกรมหลักและให้ค่าและ output ใน โปรแกรมย่อย
A
-NUM,cntr ที่กาหนดให้ในโปรแกรมย่อย B เป็น Local B ซึ่งเป็นดปรแกรมหลัก หรือโปรแกรมย่อยอื่นๆ จะนาไปใช้ไม่ได้
แต่ชื่อ NUM ซ้ากับ NUM ในโปรแกรมหลัก จึงถือว่าเป็นคนละ NUM กัน ที่โปรแกรมหลัก NUM=5 แต่พอถึง A นามา
คูณ 10 ได้ 50 เมื่อถึง B ให้ค่าใหม่เป็น124 เมื่อกลับมาเป็นโปรแกรมหลักก็เป็น 124 แต่ยังเป็น 50 เพราะเป็น NUM
คนละตัวกัน
-ก่อน Procedure B ได้กาหนดตัวแปร ANY ซึ่งเป็นโกบอล แต่ใช้ใน Procedure A ไม่ได้ใช้ใน Procedure B
และโปรแกรมหลัก
-เพราะฉะนั้น B เรียกใช้ A แต่ A เรียกใช้ B ไม่ได้ และทั้ง A,B รัยกใช้ A,A ไม่ได้ เพราะเป็นโปรแกรมหลัก
โปรแกรมย่อย

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

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

23. • ฟังก์ชันทำงคณิตศำสตร์ (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)
ฟังก์ชันมาตรฐาน (standard functions)

24. 1) ฟังก์ชัน acos(x)
เป็นฟังก์ชันที่ใช้คานวณหาค่า arc cosine ของ x โดยที่ x เป็นค่ามุมในหน่วย
เรเดียน (radian)
รูปแบบ
acos(x);
2) ฟังก์ชัน asin(x)
เป็นฟังก์ชันที่ใช้คานวณหาค่า arc sine ของ x โดยที่ x เป็นค่ามุมในหน่วยเรเดียน
รูปแบบ
asin(x);
ฟังก์ชันมาตรฐาน (standard functions)

25. 3) ฟังก์ชัน atan(x)
เป็นฟังก์ชันที่ใช้คานวณหาค่า arc tan ของ x โดยที่ x เป็นค่ามุมในหน่วย
เรเดียน
รูปแบบ
atan(x);
4) ฟังก์ชัน sin(x)
เป็นฟังก์ชันที่ใช้คานวณหาค่า sine ของ x โดยที่ x เป็นค่ามุมในหน่วยเรเดียน
รูปแบบ
sin(x);
ฟังก์ชันมาตรฐาน (standard functions)

26. 5) ฟังก์ชัน cos(x)
เป็นฟังก์ชันที่ใช้คานวณหาค่า cosine ของ x โดยที่ x เป็นค่ามุมในหน่วยเรเดียน
รูปแบบ
cos(x);
6) ฟังก์ชัน tan(x)
เป็นฟังก์ชันที่ใช้คานวณหาค่า tan ของ x โดยที่ x เป็นค่ามุมในหน่วยเรเดียน
รูปแบบ
tan(x);
ฟังก์ชันมาตรฐาน (standard functions)

27. ฟังก์ชันมาตรฐาน (standard functions)
• โปรแกรมตัวอย่ำงที่ 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(“%fn”,asin(r)); /* บรรทัดที่ 9 */
printf(“%fn”,acos(r)); /* บรรทัดที่ 10 */
printf(“%fn”,atan(r)); /* บรรทัดที่ 11 */
printf(“%fn”,sin(r)); /* บรรทัดที่ 12 */
printf(“%fn”,cos(r)); /* บรรทัดที่ 13 */
printf(“%fn”,tan(r)); /* บรรทัดที่ 14 */
printf(“nPress any key back to program …”); /* บรรทัด
ที่ 15 */
getch(); /* บรรทัดที่ 16 */
} /* บรรทัดที่ 17 */

28. • ผลลัพธ์ที่ได้จำกโปรแกรม
คำอธิบำยโปรแกรม
จากโปรแกรมตัวอย่างที่ 7.1 สามารถอธิบายการทางานของโปรแกรมที่สาคัญ ๆ ได้ดังนี้
บรรทัดที่ 9 คาสั่ง printf(“%fn”,asin(r)); ฟังก์ชันคานวณหาค่า arc sin ของตัวแปร r โดย r เป็นมุมในหน่วยเรเดียน และแสดงผลลัพธ์ที่ได้
ออกจอภาพ
บรรทัดที่ 10 คาสั่ง printf(“%fn”,acos(r)); ฟังก์ชันคานวณหาค่า arc cosine ของตัวแปร r โดย r เป็นมุมในหน่วยเรเดียน และแสดง
ผลลัพธ์ที่ได้ออกจอภาพ
บรรทัดที่ 11 คาสั่ง printf(“%fn”,atan(r)); ฟังก์ชันคานวณหาค่า arc tan ของตัวแปร r โดย r เป็นมุมในหน่วยเรเดียน และแสดงผลลัพธ์ที่ได้
ออกจอภาพ
บรรทัดที่ 12 คาสั่ง printf(“%fn”,sin(r)); ฟังก์ชันคานวณหาค่า sine ของตัวแปร r โดย r เป็นมุมในหน่วยเรเดียน และแสดงผลลัพธ์ที่ได้ออก
จอภาพ
บรรทัดที่ 13 คาสั่ง printf(“%fn”,cos(r)); ฟังก์ชันคานวณหาค่า cosine ของตัวแปร r โดย r เป็นมุมในหน่วยเรเดียน และแสดงผลลัพธ์ที่ได้
ออกจอภาพ
บรรทัดที่ 14 คาสั่ง printf(“%fn”,tan(r)); ฟังก์ชันคานวณหาค่า tan ของตัวแปร r โดย r เป็นมุมในหน่วยเรเดียน และแสดงผลลัพธ์ที่ได้ออก
จอภาพ
บรรทัดที่ 15 และ 16 พิมพ์ข้อความให้กดคีย์ใด ๆ เพื่อกลับสู่โปรแกรม และหยุดรอรับค่าใด ๆ เช่น กด enter จะกลับเข้าสู่โปรแกรม
ฟังก์ชันมาตรฐาน (standard functions)

29. 7) ฟังก์ชัน sqrt(x)
เป็นฟังก์ชันที่ใช้หาค่ารากที่ 2 (square root) ของค่าคงที่หรือตัวแปร x โดย
ที่ x จะต้องเป็นค่าคงที่ชนิดตัวเลขหรือตัวแปรที่มีค่าไม่ติดลบ
รูปแบบ
sqrt(x);
8) ฟังก์ชัน exp(x)
เป็นฟังก์ชันที่ใช้หาค่า ex โดยที่ x เป็นค่าคงที่หรือตัวแปรที่จะใช้เป็นค่ายกกาลัง
ของ e โดยที่ e มีค่าประมาณ 2.718282
รูปแบบ
exp(x);
ฟังก์ชันมาตรฐาน (standard functions)

30. 9) ฟังก์ชัน pow(x,y)
เป็นฟังก์ชันที่ใช้หาค่า xy โดยที่
x เป็นค่าคงที่หรือตัวแปรที่ใช้เป็นตัวฐานซึ่งจะต้องมีค่ามากกว่าศูนย์
y เป็นค่าคงที่หรือตัวแปรที่ใช้เป็นค่ายกกาลัง
รูปแบบ
pow(x, y);
ฟังก์ชันมาตรฐาน (standard functions)

31. • โปรแกรมตัวอย่ำงที่ 2 แสดงการใช้งานฟังก์ชัน sqrt(x), exp(x) และ pow(x, y)
/* math2.c */
#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(“%.4fn”,pow(x,y)); /* บรรทัดที่ 8 */
printf(“%.4fn”,sqrt(z)); /* บรรทัดที่ 9 */
printf(“%.4fn”,exp(y)); /* บรรทัดที่ 10 */
printf(“nPress any key back to program …”); /* บรรทัดที่ 11 */
getch(); /* บรรทัดที่ 12 */
} /* บรรทัดที่ 13 */
include<stdio.h> /* บรรทัดที่ 1 */
#
ฟังก์ชันมาตรฐาน (standard functions)

32. • ผลลัพธ์ที่ได้จำกโปรแกรม
คำอธิบำยโปรแกรม
จากโปรแกรมตัวอย่างที่ 7.2 สามารถอธิบายการทางานของโปรแกรมที่สาคัญ ๆ ได้ดังนี้
บรรทัดที่ 8 คาสั่ง printf(“%.4fn”,pow(x,y)); ฟังก์ชันคานวณหาค่า xy โดยที่ x เป็นค่าคงที่หรือตัวแปรที่ใช้ตัวฐานซึ่งจะต้องมีค่า
มากกว่าศูนย์ และ y เป็นค่าคงที่หรือตัวแปรที่ใช้เป็นค่ายกกาลัง และแสดงผลที่ได้ออกจอภาพ
บรรทัดที่ 9 คาสั่ง printf(“%.4fn”,sqrt(z)); ฟังก์ชันคานวณหาค่ารากที่สอง (square root) ของค่าคงที่หรือตัว
แปร z โดยที่ z จะต้องเป็นค่าคงที่ชนิดตัวเลขหรือตัวแปรที่มีค่าไม่ติดลบ และแสดงผลที่ได้ออกจอภาพ
บรรทัดที่ 10 คาสั่ง printf(“%.4fn”,exp(y)); ฟังก์ชันคานวณหาค่า ey โดยที่ y เป็นค่าคงที่หรือตัวแปรที่จะใช้เป็นค่ายกกาลัง
ของ e โดยที่ e มีค่าประมาณ 2.718282 และแสดงผลที่ได้ออกจอภาพ
บรรทัดที่ 11 และ 12 พิมพ์ข้อความให้กดคีย์ใด ๆ เพื่อกลับสู่โปรแกรม และหยุดรอรับค่าใด ๆ เช่น กด enter จะกลับเข้าสู่โปรแกรม
ฟังก์ชันมาตรฐาน (standard functions)

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

34. • โปรแกรมตัวอย่ำงที่ 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(“%.4fn”,log(n)); /* บรรทัดที่ 8 */
printf(“%.4fn”,log10(m)); /* บรรทัดที่ 9 */
printf(“nPress any key back to program …”); /* บรรทัด
ที่ 10 */
getch(); /* บรรทัดที่ 11 */
} /* บรรทัดที่ 12 */
ฟังก์ชันมาตรฐาน (standard functions)

35. • ผลลัพธ์ที่ได้จำกโปรแกรม
คำอธิบำยโปรแกรม
บรรทัดที่ 8 คาสั่ง printf(“%.4fn”,log(n)); ฟังก์ชันที่ใช้หาค่า log ฐาน n (natural
logorithm) ของค่าคงที่หรือตัวแปร n โดยที่ n เป็นค่าคงที่หรือตัวแปรที่มีค่าเป็นลบไม่ได้ และ
แสดงผลที่ได้ออกจอภาพ
บรรทัดที่ 9 คาสั่ง printf(“%.4fn”,log10(m)); ฟังก์ชันที่ใช้หาค่า log ฐาน 10 ของ
ค่าคงที่หรือตัวแปร m โดยที่ m เป็นค่าคงที่หรือตัวแปรที่มีค่าเป็นลบไม่ได้ และแสดงผลที่ได้ออก
จอภาพ
บรรทัดที่ 10 และ 11 พิมพ์ข้อความให้กดคีย์ใด ๆ เพื่อกลับสู่โปรแกรม และหยุดรอรับค่าใด
ๆ เช่น กด enter จะกลับเข้าสู่โปรแกรม
ฟังก์ชันมาตรฐาน (standard functions)

36. 12) ฟังก์ชัน ceil(x)
เป็นฟังก์ชันที่ใช้ในการปัดเศษทศนิยมขึ้นของตัวแปร x ถ้า x เป็นตัวเลขจานวนทศนิยม แต่
ถ้า x เป็นเลขจานวนเต็มจะไม่มีการปัดเศษทศนิยม
รูปแบบ
ceil(x);
13) ฟังก์ชัน floor(x)
เป็นฟังก์ชันที่ใช้ในการตัดเศษทศนิยมทิ้งของตัวแปร x ถ้า x เป็นตัวเลขจานวนทศนิยม แต่
ถ้า x เป็นเลขจานวนเต็มจะไม่มีการตัดเศษทศนิยมทิ้ง
รูปแบบ
floor(x);
ฟังก์ชันมาตรฐาน (standard functions)

37. • โปรแกรมตัวอย่ำงที่ 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(“%.4fn”, ceil(9.8765)); /* บรรทัดที่ 7 */
printf(“%.4fn”, ceil(-3.7654)); /* บรรทัดที่ 8 */
printf(“%.4fn”, ceil(80)); /* บรรทัดที่ 9 */
printf(“%.4fn”, floor(7.9876)); /* บรรทัดที่ 10 */
printf(“%.4fn”, floor(-3.321)); /* บรรทัดที่ 11 */
printf(“%.4fn”, floor(180)); /* บรรทัดที่ 12 */
printf(“nPress any key back to program …”); /* บรรทัดที่ 13 */
getch(); /* บรรทัดที่ 14 */
} /* บรรทัดที่ 15 */
ฟังก์ชันมาตรฐาน (standard functions)

38. • ผลลัพธ์ที่ได้จำกโปรแกรม
คำอธิบำยโปรแกรม
จากโปรแกรมตัวอย่างที่ 7.4 สามารถอธิบายการทางานของโปรแกรมที่สาคัญ ๆ ได้ดังนี้
บรรทัดที่ 7 คาสั่ง printf(“%.4fn”,ceil(9.8765)); ฟังก์ชันที่ใช้ในการปัดเศษทศนิยมขึ้นของตัวเลข 9.8765 และแสดงผลออกที่จอภาพ
บรรทัดที่ 8 คาสั่ง printf(“%.4fn”,ceil(-3.7654)); ฟังก์ชันที่ใช้ในการปัดเศษทศนิยมขึ้นของตัวเลข -3.7654 และแสดงผลออกที่จอภาพ
บรรทัดที่ 9 คาสั่ง printf(“%.4fn”,ceil(80)); ฟังก์ชันที่ใช้ในการปัดเศษทศนิยมขึ้นของตัวเลข 80 และแสดงผลออกที่จอภาพ
บรรทัดที่ 10 คาสั่ง printf(“%.4fn”,floor(7.9876)); ฟังก์ชันที่ใช้ในการตัดเศษทศนิยมทิ้งของตัวเลข 7.9876 และแสดงผลออกที่จอภาพ
บรรทัดที่ 11 คาสั่ง printf(“%.4fn”,floor(-3.321)); ฟังก์ชันที่ใช้ในการตัดเศษทศนิยมทิ้งของตัวเลข -3.321 และแสดงผลออกที่จอภาพ
บรรทัดที่ 12 คาสั่ง printf(“%.4fn”,floor(180)); ฟังก์ชันที่ใช้ในการตัดเศษทศนิยมทิ้งของตัวเลข 180 และแสดงผลออกที่จอภาพ
บรรทัดที่ 13 และ 14 พิมพ์ข้อความให้กดคีย์ใด ๆ เพื่อกลับสู่โปรแกรม และหยุดรอรับค่าใด ๆ เช่น กด enter จะกลับเข้าสู่โปรแกรม
ฟังก์ชันมาตรฐาน (standard functions)

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

40. • ฟังก์ชันเกี่ยวกับตัวอักษร (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)
ฟังก์ชันมาตรฐาน (standard functions)

41. 1) ฟังก์ชัน isalnum(ch)
เป็นฟังก์ชันที่ใช้ตรวจสอบว่าข้อมูลที่เก็บไว้ในตัวแปร ch เป็นตัวอักษรหรือตัวเลข (letter or digit) ถ้าข้อมูลที่เก็บไว้เป็น
ตัวอักษรหรือตัวเลขก็จะส่งค่ากลับที่เป็นจานวนเต็มที่มีค่าไม่เท่ากับศูนย์มายังฟังก์ชัน และถ้าข้อมูลที่เก็บไว้ในตัวแปร ch ไม่ได้เก็บ
ตัวอักษรหรือตัวเลขก็จะส่งค่ากลับที่มีค่าเป็นศูนย์มายังฟังก์ชัน
รูปแบบ
isalnum(ch);
2) ฟังก์ชัน isalpha(ch)
เป็นฟังก์ชันที่ใช้ตรวจสอบว่าข้อมูลที่เก็บไว้ในตัวแปร ch เป็นตัวอักษร (letter) หรือไม่ ถ้าใช่ฟังก์ชันนี้จะให้ค่าส่งกลับเป็นเลข
จานวนเต็มที่ไม่เท่ากับศูนย์ ถ้าไม่ใช่ฟังก์ชันนี้จะให้ค่าส่งกลับมาเป็นเลขศูนย์ (0)
รูปแบบ
isalpha(ch);
ฟังก์ชันมาตรฐาน (standard functions)

42. 3) ฟังก์ชัน isdigit(ch)
เป็นฟังก์ชันที่ใช้ตรวจสอบว่าข้อมูลที่เก็บไว้ในตัวแปร ch เป็นตัวเลข 0 ถึง 9 หรือไม่ ถ้าใช่ฟังก์ชันนี้จะให้ค่า
ส่งกลับเป็นเลขจานวนเต็มที่ไม่เท่ากับศูนย์ ถ้าไม่ใช่ฟังก์ชันนี้จะไม่มีการส่งค่ากลับ
รูปแบบ
isdigit(ch);
4) ฟังก์ชัน islower(ch)
เป็นฟังก์ชันที่ใช้ตรวจสอบว่าข้อมูลที่เก็บไว้ในตัวแปร ch เป็นตัวอักษรตัวเล็กหรือไม่ ถ้าใช่ให้ส่งค่ากลับเป็นเลขจานวน
เต็มที่ไม่เท่ากับศูนย์ ถ้าไม่ใช่ฟังก์ชันนี้จะให้ค่าส่งกลับเป็นเลขศูนย์ (0)
รูปแบบ
islower(ch);
ฟังก์ชันมาตรฐาน (standard functions)

43. 5) ฟังก์ชัน isupper(ch)
เป็นฟังก์ชันที่ใช้ตรวจสอบว่าข้อมูลที่เก็บไว้ในตัวแปร ch เป็นตัวอักษรตัวใหญ่หรือไม่ ถ้าใช่ให้ส่งค่ากลับ
เป็นเลขจานวนเต็มที่ไม่เท่ากับศูนย์ ถ้าไม่ใช่ฟังก์ชันนี้จะให้ค่าส่งกลับเป็นเลขศูนย์ (0)
รูปแบบ
isupper(ch)
6) ฟังก์ชัน tolower(ch)
เป็นฟังก์ชันที่ใช้เปลี่ยนตัวอักษรตัวใหญ่ที่เก็บไว้ในตัวแปร ch ให้เป็นอักษรตัวเล็ก
รูปแบบ
tolower(ch);
ฟังก์ชันมาตรฐาน (standard functions)

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

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

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

47. 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 สงวนไว้
ฟังก์ชันมาตรฐาน (standard functions)

48. 3) ฟังก์ชัน clreol( )
เป็นฟังก์ชันที่ใช้ลบข้อความในบรรทัดที่ตัว cursor อยู่ โดยลบข้อความถัดจากตาแหน่งของ cursor ไป
จนกระทั่งจบบรรทัด
รูปแบบ
clreol( );
4) ฟังก์ชัน deline( )
เป็นฟังก์ชันที่ใช้ลบข้อความทั้งบรรทัดที่มีตัว cursor อยู่ จากนั้นก็เลื่อนข้อความในบรรทัดที่อยู่ข้างล่างขึ้นมาแทนที่
รูปแบบ
deline( );
ฟังก์ชันมาตรฐาน (standard functions)

49. 5) ฟังก์ชัน insline( )
เป็นฟังก์ชันที่ใช้แทรกบรรทัดว่าง 1 บรรทัด โดยแทรกอยู่ใต้บรรทัดที่มี cursor อยู่
รูปแบบ
insline( );
6) ฟังก์ชัน sizeof(x)
เป็นฟังก์ชันที่ใช้ตรวจสอบขนาดของตัวแปร x ว่ามีขนาดกี่ Byte
รูปแบบ
sizeof(x);
หรือ sizeof(type);
โดยที่
x เป็นชื่อตัวแปรที่ต้องการตรวจสอบขนาด
type เป็นชนิดของตัวแปร เช่น int, float, char, double เป็นต้น
ฟังก์ชันมาตรฐาน (standard functions)

50. 7) ฟังก์ชัน system( )
เป็นฟังก์ชันที่ช่วยให้สามารถเรียกใช้คาสั่งที่อยู่ใน MS-DOS มาใช้งานได้
รูปแบบ
system(“dos-command”);
โดยที่
dos-command คือคาสั่ง dos ที่ต้องการใช้ เช่น cls, dir, date, time, etc. เป็นต้น
8) ฟังก์ชัน abort( )
เป็นฟังก์ชันที่ใช้ยกเลิกการทางานของโปรแกรมโดยทันที่ทันใดไม่ว่าจะทางานเสร็จหรือไม่ และจะมีข้อความ
บอกว่า “Abnormal program termination” แสดงออกทางจอภาพด้วย
รูปแบบ
abort( );
ฟังก์ชันมาตรฐาน (standard functions)

51. 9) ฟังก์ชัน abs(x)
เป็นฟังก์ชันที่ใช้ค่าสัมบูรณ์ของ x โดยที่ x เป็นตัวแปรที่เก็บตัวเลขจานวนเต็มเท่านั้น
รูปแบบ
abs(x);
10) ฟังก์ชัน labs(x)
เป็นฟังก์ชันที่ใช้หาค่าสมบูรณ์ของ x โดยที่ x เป็นตัวแปรที่เก็บตัวเลขชนิด long integer
รูปแบบ
labs(x);
ฟังก์ชันมาตรฐาน (standard functions)

52. 11) ฟังก์ชัน atoi(s)
เป็นฟังก์ชันที่เปลี่ยนค่า string ให้เป็นตัวเลขจานวนเต็ม (integer) ที่สามารถ
นาไปคานวณได้
รูปแบบ
atoi(s);
12) ฟังก์ชัน atof(s)
เป็นฟังก์ชันที่ใช้เปลี่ยนค่า string ให้เป็นตัวเลขจานวนทศนิยม (floating
point) ที่สามารถนาไปคานวณได้
รูปแบบ
atof( );
ฟังก์ชันมาตรฐาน (standard functions)

53. 13) ฟังก์ชัน atol(s)
เป็นฟังก์ชันที่ใช้เปลี่ยนค่า string ให้เป็นตัวเลขจานวนเต็ม
ชนิด long integer ที่สามารถนาไปใช้คานวณได้
รูปแบบ
atol(s);
ฟังก์ชันมาตรฐาน (standard functions)

54. 1. นายนครินทร์ หรสิทธิ์ เลขที่ 8
2. นางสาวปิยกมล ปูรณวัฒนกุล เลขที่ 11
3. นางสาวลัชชา ยมะคุปต์ เลขที่ 13
4. นางสาวเกศินี อุฬูทิศ เลขที่ 16
5. นางสาวจุฑารัตน์ โชติกาญจนวงศ์ เลขที่ 18
6.นางสาวปิยธิดา อมรมงคลศิลป์ เลขที่ 20
7. นางสาวณิชกานต์ แดงจันทร์ เลขที่ 29
ชั้นมัธยมศึกษาปีที่ 6/1
ผู้จัดทา

55. อาจารย์ทรงศักดิ์โพธิ์เอี่ยม
เสนอ