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

• รูปแบบของฟังก์ชันประเภทนี้ คือ
ชนิดข้อมูลที่ต้องการส่งกลับออกไป ชื่อฟังก์ชัน(ชนิดข้อมูลที่รับเข้ามา ชื่อตัวแปรที่รับเข้ามา)
{
รูปแบบ ...
return ค่าที่ต้องการส่งคืนกลับออกไปจากฟังก์ชัน
}

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

• การเรียกใช้งานฟังก์ชันย่อยประเภทที่มกี ารรับค่าเข้ามาในฟังก์ชัน แต่มีการส่งคืนค่า

กลับออกไปจากฟังก์ชัน ทำได้โดยระบุ ดังนี้

รูปแบบ ตัวแปรสำหรับรับค่าที่ฟังก์ชันย่อยส่งคืนมาให้ = ชื่อฟังก์ชันย่อย(พารามิเตอร์ที่ส่งไปยังฟังก์ชันย่อย);

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

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

int sub_function(int a, int b)

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

• สรุป ต้องระวังจุดที่ 1 2 3 ให้มีชนิดข้อมูลเป็นชนิดข้อมูลประเภทเดียวกัน

• โดยตัวแปรที่ตั้งขึ้นในจุดที่ 2 จะ3 ต้องชื่อเป็นอะไรก็ได้ไม่สำคัญ
สำคัญที่ว่าจะต้องกำหนดให้ตัวแปรนั้นมีชนิดข้อมูลเหมือนจุดที่ 1 ก็พอ
 ฟังก์ชันที่มีการรับค่าเข้ามาในฟังก์ชัน และมีการส่งค่ากลับออกไปจากฟังก์ชัน
ตัวอย่าง โปรแกรมหาค่าเฉลี่ยของตัวเลขจากฟังก์ชันสร้างเอง
1 #include <stdio.h>
2
อย่าลืมว่าถ้า return type
3 float average(float a, float b, float c, float d, float e) ไม่ใช่ void ต้องมีคำสั่ง return ด้วย
4 {
5 float average;
6 average = (a+b+c+d+e)/5; ผลลัพธ์ของโปรแกรม
7 return average;
8 }
3 5 7 11
9 2
10 main()
11 {
12
5.600000
float result, a=2, b=3, c=5, d=7, e=11; Average of 2, 3, 5, 7, 11 is 5.600000
13
14 result = average(a, b, c, d, e);
15 printf("Average of %.0f, %.0f, %.0f, %.0f, %.0f is %f\n", a, b, c, d, e, result);
16 }
 ฟังก์ชันที่มีการรับค่าเข้ามาในฟังก์ชัน และมีการส่งค่ากลับออกไปจากฟังก์ชัน
อธิบายโปรแกรม
• เป็นโปรแกรมหาค่าเฉลีย่ ของเลขจำนวนเต็ม 5 จำนวน โดยในบรรทัดที่ 14 เรียกใช้งาน
ฟังก์ชันย่อย average() พร้อมทั้งส่งค่าเลขจำนวนเต็ม 5 ตัว คือ ค่าของตัวแปร a, b, c, d, e
ไปให้ (สังเกตว่าสามารถส่งพารามิเตอร์หลายตัวไปยังฟังก์ชันย่อยได้) และในบรรทัดนี้มี
การนำตัวแปร result ที่มีชนิดข้อมูลเป็น float มารับค่าที่ฟังก์ชันย่อย average()
จะส่งคืนกลับมาให้ด้วย
• บรรทัดที่ 3-8 เป็นฟังก์ชันย่อย average() ซึ่งบรรทัดที่ 6 จะทำการหาค่าเฉลี่ยของเลขทั้ง
5 จำนวน ที่รับเข้ามา ได้ผลลัพธ์เท่าใด เก็บลงในตัวแปร average จากนั้นบรรทัดที่ 7 ส่งค่า
ตัวแปร average นี้ กลับออกไปนอกฟังก์ชัน ขอให้สังเกตว่าหน้าฟังก์ชันย่อย average()
กำหนดชนิดข้อมูลเป็น float ดังนั้น ตัวแปรที่จะส่ง return ก็ต้องมีชนิดข้อมูลเป็น float ด้วย
 ฟังก์ชันที่มีการรับค่าเข้ามาในฟังก์ชัน และมีการส่งค่ากลับออกไปจากฟังก์ชัน
ตัวอย่าง โปรแกรมหาพื้นที่สี่เหลี่ยมจัตุรัสโดยใช้ฟังก์ชันย่อยช่วยในการทำงาน
1 #include <stdio.h> 14 int sqr(int side)
2 15 {
3 int sqr(int side); 16 int area = side*side;
4 void printArea(int side, int area); 17 return area;
5 18 }
6 main() 19
7 { 20 void printArea(int side, int area)
8 int side; 21 {
9 printf("Please enter side of square : "); 22 printf("Square area of %d*%d is %d\n", side, side, area);
10 scanf("%d", &side); 23 }
11 int area = sqr(side);
12 printArea(side, area);
13 }
ผลลัพธ์ของ Please enter side of square : 5
โปรแกรม Square area of 5*5 is 25
 ฟังก์ชันที่ไม่มีการรับค่าเข้ามาในฟังก์ชัน แต่มีการส่งค่ากลับออกไปจากฟังก์ชัน
• รูปแบบของฟังก์ชันประเภทนี้ คือ
ชนิดข้อมูลที่ต้องการส่งกลับออกไป ชื่อฟังก์ชัน(void)
{
รูปแบบ ...
return ค่าที่ต้องการส่งคืนกลับออกไปจากฟังก์ชัน
}

• ฟังก์ชันประเภทนี้ไม่มีการรับค่าเข้ามาในฟังก์ชันย่อย แต่มีการทำงานหนึ่ง ๆ ภายในฟังก์ชันย่อยนั้น ๆ

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

• การเรียกใช้งานฟังก์ชันย่อยประเภทที่ไม่มกี ารรับค่าเข้ามาในฟังก์ชัน แต่มีการส่งคืน

ค่ากลับออกไปจากฟังก์ชัน ทำได้โดยระบุ ดังนี้

รูปแบบ ตัวแปรสำหรับรับค่าที่ฟังก์ชันย่อยส่งคืนมาให้ = ชื่อฟังก์ชันย่อย;

 ฟังก์ชันที่ไม่มีการรับค่าเข้ามาในฟังก์ชัน แต่มีการส่งค่ากลับออกไปจากฟังก์ชัน
ตัวอย่าง โปรแกรมแสดงการทำงานของฟังก์ชันสร้างเองประเภทนี้
1 #include <stdio.h> 12 int sub_function(void)
2
3 int sub_function(void); 13 {
4 14 int ret_val=5,i;
5 main() 15 for(i=0; i<5; i++)
6 {
7 int value; 16 ret_val = ret_val+i;
8 printf("This program will call sub function to return value\n"); 17 return ret_val;
9 value = sub_function(); 18 }
10 printf("Return value from sub function is %d\n", value);
11 }

This program will call sub function to return value

ผลลัพธ์ของโปรแกรม Return value from sub function is 64
 ฟังก์ชันที่มีการรับค่าเข้ามาในฟังก์ชัน และมีการส่งค่ากลับออกไปจากฟังก์ชัน
อธิบายโปรแกรม

• บรรทัดที่ 9 เรียกใช้งานฟังก์ชันย่อย sub_function() โดยไม่มีการส่งค่าใด ๆ

จากฟังก์ชันหลักไปยังฟังก์ชันย่อย แต่ได้มีการนำตัวแปร value มารับค่าที่
ฟังก์ชันย่อย sub_function() จะส่งคืนกลับมาให้
• บรรทัดที่ 12-18 เป็นส่วนของฟังก์ชันย่อย sub_function() ซึ่งฟังก์ชนั นี้
ไม่มีการรับค่าใด ๆ เข้ามาในฟังก์ชัน แต่มีการประมวลผลค่าของฟังก์ชันด้วยตัวแปร
ret_val ซึ่งเมื่อประมวลผลสำเร็จแล้ว ได้ส่งค่าของตัวแปร ret_val กลับออกไป
จากฟังก์ชันด้วย
 อาร์เรย์กับฟังก์ชันสร้างเอง

• การนำอาร์เรย์มาใช้งานร่วมกับฟังก์ชันสร้างเอง
• โดยสามารถส่งค่าของอาร์เรย์ไปยังฟังก์ชันสร้างเองได้
 อาร์เรย์กับฟังก์ชันสร้างเอง
ตัวอย่าง โปรแกรมนับจำนวนตัวอักษรในข้อความ (ไม่รวมช่องว่าง)
1 #include <stdio.h> การประกาศอาร์กิวเมนต์เพื่อรับค่าพารามิเตอร์ในลักษณะของอาร์เรย์นั้น ให้กำหนดชนิดข้อมูลและชื่อตัวแปรอาร์เรย์ โดยไม่ต้องกำหนดขนาดของอาร์เรย์
2
3 int count(char word[]) 23 main() 28 fgets(word, 50, stdin);
4 { 24 { 29 length = count(word);
5 int i=0,counter=0; 25 char word[50]; 30 printf("Length of your word is %d\n", length);
6 while(word[i] != '\0') 26 int length; 31 }
7 { 27 printf("Please enter word : "); การส่งพารามิเตอร์ทำโดยระบุชื่อของอาร์เรย์โดยตรง
8 switch(word[i])
9 {
10
11
case ' ' :
break; ผลลัพธ์ของโปรแกรม
12 case '\t' :
13 break;
14 case '\n' :
15 break;
16 default :
17 counter++;
18 }
19 i++;
20 }
21 return counter;
22 }
 อาร์เรย์กับฟังก์ชันสร้างเอง
อธิบายโปรแกรม
• บรรทัดที่ 27-28 รับค่าข้อความสตริงเข้ามาในโปรแกรม
• บรรทัดที่ 29 เรียกใช้งานฟังก์ชันย่อย count() โดยส่งค่าข้อความสตริง word
เข้าไปในฟังก์ชันย่อยด้วย
• บรรทัดที่ 3-22 เป็นการทำงานของฟังก์ชันย่อย count()
o โดยบรรทัดที่ 6-20 ใช้ลูป while ตรวจสอบข้อมูล (ตัวอักษร) ในแต่ละช่อง
ของอาร์เรย์ว่าเป็น Null Character หรือไม่
o ถ้าไม่ใช่ก็จะเข้าสู่การทำงานของการตรวจสอบเงื่อนไขด้วยคำสั่งเงื่อนไข
switch-case ในบรรทัดที่ 8-18 โดยโปรแกรมนี้จะทำการตรวจสอบ
ว่าข้อความมีขนาดกี่ตัวอักษร โดยไม่นับรวมช่องว่างและ Tab 'a'
 อาร์เรย์กับฟังก์ชันสร้างเอง
o ดังนั้น ในบรรทัดที่ 10-13 จึงตรวจสอบว่าข้อมูลของอาร์เรย์ช่องที่ i มีค่าเป็นช่องว่าง
หรือ Tab หรือไม่
o ถ้าใช่ก็จะไม่ทำการบวกเพิ่มค่าของตัวแปร counter นี้ในการนับจำนวนตัวอักษร
o แต่หากค่าข้อมูลที่ตรวจสอบไม่ใช่ช่องว่างหรือ Tab ก็จะไปตรวจสอบว่าเป็น New Line
(‘\n’) หรือไม่ เพราะโดยปกติการรับค่าด้วยฟังก์ชัน fgets นั้น จะติดค่า New Line
(‘\n’) มาด้วยเสมอ
o ซึ่งถ้าเป็น New Line ก็จะไม่บวกเพิ่มค่าตัวแปร counter เช่นกัน
o แต่ถ้าไม่ใช่ New Line ก็จะเข้าสู่กรณีของ default ซึ่งจะทำการบวกเพิ่มค่าของ
ตัวแปร counter ขึ้นอีก 1 จากนั้นบรรทัดที่ 19 จะบวกเพิ่มค่า i เพื่อเลือ่ นไปพิจารณา
ข้อมูลของอาร์เรย์ในช่องถัดไป
 อาร์เรย์กับฟังก์ชันสร้างเอง
o และจะวนลูปไปเรื่อย ๆ จนกว่าจะพบ ‘\0’ จากนั้นจะส่งจำนวนตัวอักษรที่นับได้กลับคืน
ไปยังฟังก์ชันหลัก main()
o โดยในบรรทัดที่ 29 ฟังก์ชันหลัก main() ได้นำตัวแปร length มารับค่าทีฟ
่ ังก์ชันย่อย
count() จะส่งคืนกลับมาให้
o ซึ่งจากผลลัพธ์ที่แสดงในรูปภาพ ไม่ว่าจะป้อนคำว่า “computer science“
ในลักษณะอย่างไร คือ จะเว้นช่องว่างมากน้อยเท่าใด ก็ได้จำนวนตัวอักษรไม่ต่างกัน
เนื่องจากจะไม่นับรวมช่องว่างหรือ Tab เข้าไปด้วย
 อาร์เรย์กับฟังก์ชันสร้างเอง
ตัวอย่าง โปรแกรมแสดงการหาค่าสูงสุดของตัวเลข 5 ตัว ด้วยฟังก์ชันสร้างเอง
1 #include <stdio.h> 17 int findMax(int num[])
2 18 {
3 int findMax(int num[]); 19 int maximum, i=0;
4 20 maximum = num[i];
5 main() 21
6 { 22 for(i=0; i<5; i++)
7 int number[5] = { 20, 50, 100, 99, 9 }; 23 {
8 int max; 24 if(num[i] > maximum)
9 max = findMax(number); 25 maximum = num[i];
10 printf("number[1] : %d\n", number[0]); 26 }
11 printf("number[2] : %d\n", number[1]); 27 return maximum;
12 printf("number[3] : %d\n", number[2]); 28 } number[1] : 20
13 printf("number[4] : %d\n", number[3]); number[2] : 50
14 printf("number[5] : %d\n", number[4]); number[3] : 100
15 printf("Maximum of these number is %d\n", max); ผลลัพธ์ของ number[4] : 99
number[5] : 9
16 }
โปรแกรม Maximum of these number is 100
 อาร์เรย์กับฟังก์ชันสร้างเอง
อธิบายโปรแกรม

• บรรทัดที่ 21 กำหนดค่าของอาร์เรย์ช่องแรกให้กับตัวแปร maximum

• บรรทัดที่ 23-27 วนลูปทั้งหมด 5 ครั้ง เพื่อนำค่าของอาร์เรย์แต่ละช่อง
มาเปรียบเทียบกับค่าตัวแปร maximum โดยหากอาร์เรย์ช่องใดมีค่ามากกว่า
ค่าของตัวแปร maximum ก็จะกำหนดค่าของอาร์เรย์ช่องนัน้ ให้กับตัวแปร
maximum แทน ดังบรรทัดที่ 26
 พอยเตอร์กับฟังก์ชันสร้างเอง
ตัวอย่าง โปรแกรมแสดงการใช้งานพอยเตอร์ร่วมกับการทำงานของฟังก์ชันย่อย
1 #include <stdio.h> เนื่องจากอาร์กิวเมนต์ในบรรทัดที่ 14 กำหนดเป็นพอยเตอร์
2 ดังนั้น การส่งพารามิเตอร์จะส่งเป็นค่าข้อมูลไม่ได้ ต้องทำ
ผลลัพธ์ของ
3 void swap(int *, int *); การส่งพารามิเตอร์ในลักษณะของแอดเดรสของตัวแปร โปรแกรม
4
5 main() 14 void swap(int *a, int *b) Before swap
6 { 15 { x=3 , y=5
7 int x=3, y=5; 16 int tmp;
8 printf("Before swap\n"); 17 tmp = *a; After swap
9 printf("x=%d , y=%d\n\n", x, y); 18 *a = *b; x=5 , y=3
10 swap(&x, &y); 19 *b = tmp;
11 printf("After swap\n");
20 } กำหนดอาร์กิวเมนต์โดยใส่ * ไว้หน้าชื่อตัวแปร
12 printf("x=%d , y=%d\n", x, y);
13 } หมายถึง กำหนดอาร์กิวเมนต์เป็นพอยเตอร์
 พอยเตอร์กับฟังก์ชันสร้างเอง
• การส่งผ่านข้อมูลไปยังฟังก์ชัน (Parameter Passing) จะมีอยู่ 2 รูปแบบ คือ
1. Pass by Value เป็นการส่งผ่านค่าข้อมูลไปยังฟังก์ชัน
2. Pass by Reference เป็นการส่งผ่านค่าแอดเดรสของข้อมูลไปยังฟังก์ชัน
1 void add(int a, int b) 1 void add(int *a, int *b)
2 { 2 {
3 ... 3 ...
4 } Pass by Value 4 } Pass by Reference
5 main() 5 main()
6 { 6 {
7 int x=1, y=2; 7 int x=1, y=2;
8 add(x, y); 8 add(&x, &y);
9 … 9 …
10 } 10 }
 ฟังก์ชันมาตรฐานของภาษาซี

• ฟังก์ชันมาตรฐานของภาษาซี (Standard Library Functions)

• คือ ภาษาซีได้จัดเตรียมไว้ให้แล้ว
• โดยตัวอย่างของฟังก์ชันมาตรฐานที่ผู้อา่ นคุ้นเคยมาตั้งแต่ต้นแล้ว ได้แก่
printf(), scanf(), scanf_s(), fgets(), getche(), getchar(), getch(),
puts(), strlen(), strcmp() เป็นต้น
• ในหัวข้อนี้จะกล่าวถึงฟังก์ชันมาตรฐานต่าง ๆ แยกตามกลุ่มของเฮดเดอร์ไฟล์
โดยจะกล่าวถึงฟังก์ชันที่มีการใช้งานบ่อย ๆ ดังนี้
 ฟังก์ชันที่มีการประกาศไว้ในเฮดเดอร์ไฟล์ ctype.h
• ฟังก์ชัน islower()
o ฟังก์ชันนี้ใช้ตรวจสอบตัวอักษร โดยถ้าเป็นตัวอักษรตัวเล็ก (Lowercase ASCII Character)
ฟังก์ชันนี้จะคืนค่าที่ไม่ใช่ 0 กลับมาให้
o ส่วนกรณีอื่น ๆ ที่นอกเหนือนี้ ฟังก์ชันจะคืนค่า 0 มาให้
รูปแบบ int islower(int c);
• ฟังก์ชัน isupper()
o ฟังก์ชันนี้ใช้ตรวจสอบตัวอักษร โดยถ้าเป็นตัวอักษรตัวใหญ่ (Uppercase ASCII Character)
ฟังก์ชันนี้จะคืนค่าที่ไม่ใช่ 0 กลับมาให้
o ส่วนกรณีอื่น ๆ ที่นอกเหนือนี้ ฟังก์ชันจะคืนค่า 0 มาให้
รูปแบบ int isupper(int c);
 ฟังก์ชันที่มีการประกาศไว้ในเฮดเดอร์ไฟล์ ctype.h
• ฟังก์ชัน tolower()
o ฟังก์ชันนี้จะแปลงตัวอักษรจากตัวใหญ่ไปเป็นตัวเล็ก
o แต่หากตัวอักษรเป็นตัวอักษรเล็กอยู่แล้ว ฟังก์ชันนี้ก็จะไม่เปลี่ยนแปลงค่าตัวอักษรแต่อย่างใด

รูปแบบ int tolower(int c);

• ฟังก์ชัน toupper()
o ฟังก์ชันนี้จะแปลงตัวอักษรจากตัวเล็กไปเป็นตัวใหญ่
o แต่หากตัวอักษรเป็นตัวอักษรใหญ่อยู่แล้ว ฟังก์ชันนี้ก็จะไม่เปลี่ยนแปลงค่าตัวอักษรแต่อย่างใด

รูปแบบ int toupper(int c);

 ฟังก์ชันที่มีการประกาศไว้ในเฮดเดอร์ไฟล์ ctype.h
ตัวอย่าง โปรแกรมแสดงการทำงานของฟังก์ชันมาตรฐานใน ctype.h
1 #include <stdio.h> 20 printf("character is b , result of tolower();");
2 #include <ctype.h>
3 21 printf("function is %c\n", tolower('b'));
4 main() 22 printf("character is b , result of toupper();");
5 { 23 printf("function is %c\n", toupper('b'));
6 printf("character is A , result of islower();");
7 printf("function is %d\n", islower('A')); 24 }
8 printf("character is A , result of isupper();");
9 printf("function is %d\n\n", isupper('A'));
10
11 printf("character is b , result of islower();");
12 printf("function is %d\n", islower('b'));
13 printf("character is b , result of isupper();"); ผลลัพธ์
14
15
printf("function is %d\n\n", isupper('b’)); ของ
16 printf("character is A , result of tolower();"); โปรแกรม
17 printf("function is %c\n",tolower('A'));
18 printf("character is A , result of toupper();");
19 printf("function is %c\n\n",toupper('A'));
 ฟังก์ชันที่มีการประกาศไว้ในเฮดเดอร์ไฟล์ math.h
• ฟังก์ชัน double pow()
o ฟังก์ชันนี้ใช้คำนวณค่าของเลขยกกำลัง โดยนำ x ยกกำลัง y หรือ xy
รูปแบบ double pow(double x, double y);

• ฟังก์ชัน double sqrt()

o ฟังก์ชันนี้ใช้คำนวณหาค่ารากที่ 2 (Square Root) ของตัวแปร x หรือ x
รูปแบบ double sqrt(double x);
 ฟังก์ชันที่มีการประกาศไว้ในเฮดเดอร์ไฟล์ math.h
• ฟังก์ชัน double ceil()
o ฟังก์ชันนี้จะทำการปัดเศษของตัวแปร x ขึ้น
รูปแบบ double ceil(double x);
• ฟังก์ชัน double floor()
o ฟังก์ชันนี้จะทำการปัดเศษของตัวแปร x ลง
รูปแบบ double floor(double x);
• ฟังก์ชัน double fabs()
o ฟังก์ชันนี้จะทำการหาค่าสัมบูรณ์ (Absolute Value) ของตัวแปร x
รูปแบบ double fabs(double x);
 ฟังก์ชันที่มีการประกาศไว้ในเฮดเดอร์ไฟล์ math.h
ตัวอย่าง โปรแกรมแสดงการทำงานของฟังก์ชันมาตรฐานใน math.h
1 #include <stdio.h> 10 result = pow(a,b);
2 #include <math.h>
3
11 printf("a power b : %.2f\n",result);
4 main() 12
5 { 13 result = sqrt(c);
6 double a=3,b=2,c=9,d=3.5,e=-7; 14 printf("square root of c : %.2f\n",result);
7 double result;
8 15
9 printf("a=%.2f\t b=%.2f\t c=%.2f\t d=%.2f\t e=%.2f\t\n",a,b,c,d,e); 16 result = ceil(d);
17 printf("ceil of d : %.2f\n",result);
18
19 result = floor(d);
ผลลัพธ์ 20 printf("floor of d : %.2f\n",result);
ของ 21
โปรแกรม 22 result = fabs(e);
23 printf("absolute of e : %.2f\n",result);
24 }
 ฟังก์ชันที่มีการประกาศไว้ในเฮดเดอร์ไฟล์ stdlib.h
• ฟังก์ชัน double atof()
o ฟังก์ชันนี้จะแปลงค่าสตริงที่ s ชี้อยู่ให้เป็น double
รูปแบบ double atof(const char *s);
• ฟังก์ชัน int atoi()
o ฟังก์ชันนี้จะแปลงค่าสตริงที่ s ชี้อยู่ให้เป็น int
รูปแบบ int atoi(const char *s);
• ฟังก์ชัน long int atol()
o ฟังก์ชันนี้จะแปลงค่าสตริงที่ s ชี้อยู่ให้เป็น long int
รูปแบบ long int atol(const char *s);
 ฟังก์ชันที่มีการประกาศไว้ในเฮดเดอร์ไฟล์ stdlib.h
• ฟังก์ชัน int rand()
o ฟังก์ชันนี้จะคืนค่าตัวเลขที่ทำการสุ่มได้ (Random) กลับมาให้
รูปแบบ int rand(void);
• ฟังก์ชัน void srand()
o ฟังก์ชันนี้จะทำการกำหนดค่าเริ่มต้นให้กับการสุ่มตัวเลข คือ จะกำหนดว่าต้องเริ่มสุ่มตัวเลข
เริ่มจากเลขใด ซึ่งค่าตัวเลขที่สุ่มมาได้นั้นก็จะเป็นค่าเริ่มต้นให้กับการสุ่มตัวเลขในครั้งต่อไป
o ส่วนใหญ่จะใช้งานฟังก์ชัน srand() ร่วมกับฟังก์ชัน rand() ในการกำหนดค่าเริ่มต้น
ในการสุ่มตัวเลขแล้ว โดยทั่วไปฟังก์ชัน rand() ก็จะทำการสุ่มตัวเลขเริ่มต้นจากเลข 1
ซึ่งมีผลทำให้ตัวเลขสุ่มได้นั้นเป็นตัวเลขชุดเดิม ซึ่งจะต้องใช้เฮดเดอร์ไฟล์ #include <time.h>
รูปแบบ void srand(time(NULL));
 ฟังก์ชันที่มีการประกาศไว้ในเฮดเดอร์ไฟล์ stdlib.h
ตัวอย่าง โปรแกรมแสดงการทำงานของฟังก์ชันมาตรฐานใน stdlib.h
1 #include <stdio.h> 17 printf("Double number is %.2f\n", f);
2 #include <stdlib.h>
3
18 printf("Integer number is %d\n", i);
4 main() 19 printf("Long number is %ld\n", l);
5 { 20 }
6 double f=0;
7 int i=0;
8
9
long l=0; ผลลัพธ์ของโปรแกรม
10 f = atof("4");
11 i = atoi("3");
12 l = atol("2");
13
14 f = f*1.5;
15 i = i+3;
16 l = l-1;
 ฟังก์ชันที่มีการประกาศไว้ในเฮดเดอร์ไฟล์ stdlib.h
ตัวอย่าง โปรแกรมแสดงการทำงานของฟังก์ชันมาตรฐาน rand() และ srand()
1 #include <stdio.h> ผลลัพธ์ของโปรแกรม
2 #include <stdlib.h>
3 #include <time.h>
4 main()
5 {
6 int i,rand_num;
7 srand(time(NULL));
8 printf("Random number between 10 to 30 is %d\n",rand()%21+10);
9 printf("Random number between 1 to 10 is %d\n",rand()%10+1);
10 printf("Random number between -1 to 100 is %d\n",rand()%102-1);
11 }
 ฟังก์ชันที่มีการประกาศไว้ในเฮดเดอร์ไฟล์ stdlib.h
อธิบายโปรแกรม

• บรรทัดที่ 7 ใช้ฟังก์ชัน srand() ในการสุ่มค่าตัวเลขแบบไม่ซ้ากันในแต่ละครั้ง

• บรรทัดที่ 8-10 ใช้ฟังก์ชัน rand() ทำการสุ่มตัวเลข โดยค่าที่สุ่มได้จากบรรทัดที่ 7
จะถูกกำหนดให้เป็นค่าเริ่มต้นในการสุ่มตัวเลขให้กับบรรทัดที่ 8 และค่าตัวเลขที่สุ่มได้
จากบรรทัดที่ 8 จะถูกกำหนดให้เป็นค่าเริ่มต้นในการสุ่มตัวเลขให้กับบรรทัดที่ 9
รวมถึงค่าตัวเลขที่สุ่มได้จากบรรทัดที่ 9 จะถูกกำหนดให้เป็นค่าเริ่มต้นในการสุ่ม
ตัวเลขให้กับบรรทัดที่ 10 ด้วย โดยการสุ่มตัวเลขมีการกำหนดด้วยว่าจะสุ่มตัวเลข
ในช่วงใดออกมา เช่น
 ฟังก์ชันที่มีการประกาศไว้ในเฮดเดอร์ไฟล์ stdlib.h
• บรรทัดที่ 8 ต้องการสุ่มตัวเลขที่มีค่าอยู่ระหว่าง 10 ถึง 30 ดังนัน้ ต้องเขียนว่า
rand() %21+10 โดย 21 มาจาก 31-10 มีค่าเท่ากับ 21 จากนั้นนำมาบวกด้วย 10
• บรรทัดที่ 9 สุ่มตัวเลขโดยเขียนว่า rand()%10+1 เนื่องจากต้องการให้ตัวเลขที่สุ่มได้
มีค่าอยู่ระหว่าง 1 ถึง 10 ซึ่งจาก rand()%10+1 นั้น ค่า 10 มาจาก 11-1 ได้ 10
จากนั้นบวกด้วย 1
• บรรทัดที่ 10 ต้องการสุ่มตัวเลขที่มีค่าอยู่ระหว่าง -1 ถึง 100 โดยเขียนว่า
rand()% 102-1 ซึ่ง 102 มาจาก 101-(-1) จากนั้นบวกด้วย -1
 ฟังก์ชันที่มีการประกาศไว้ในเฮดเดอร์ไฟล์ string.h
• ฟังก์ชัน char *strchr()
o เป็นฟังก์ชันที่ใช้ค้นหาสตริงที่อยู่ต่อจากตัวอักษร ch ทั้งหมด
รูปแบบ char *strchr(const char *string, int ch);

• ฟังก์ชัน char *strstr()

o ใช้ค้นหา Sub String ที่อยู่ใน String ที่กำหนด
รูปแบบ char *strstr(const char *string, const char *sub_string);
 ฟังก์ชันที่มีการประกาศไว้ในเฮดเดอร์ไฟล์ string.h
• ฟังก์ชัน void *memcpy()
o ฟังก์ชันนี้จะทำการคัดลอก (Copy) ตัวอักษร n ตัว จากค่าที่ s2 ชี้อยูไ่ ปยังค่าที่ s1 ชี้อยู่

รูปแบบ void *memcpy(void *s1, const void *s2, size_t n);

• ฟังก์ชัน void *memmove()

o ทำการคัดลอก (Copy) ตัวอักษร n ตัว จากค่าที่ s2 ชี้อยู่ไปที่ s1 ชี้อยู่
o โดยฟังก์ชันนี้จะทำงานเหมือนฟังก์ชัน memcpy() ทุกประการ เพียงแต่ฟังก์ชันนี้
จะสามารถทำงานได้ในกรณีที่ s1 และ s2 มีการเหลื่อมล้า (Overlap) กันอยู่
รูปแบบ void *memmove(void *s1, const void *s2, size_t n);
 ฟังก์ชันที่มีการประกาศไว้ในเฮดเดอร์ไฟล์ string.h
• ฟังก์ชัน void *memcmp()
o ฟังก์ชันนี้จะเปรียบเทียบตัวอักษร n ตัวแรกของค่าที่ s1 ชี้อยู่กับค่าที่ s2 ชี้อยู่
o โดยถ้า s1 < s2 แล้วฟังก์ชันจะคืนค่าที่น้อยกว่า 0 และ
o ถ้า s1 = s2 จะคืนค่า 0 มาให้ และ
o ถ้า s1 > s2 จะคืนค่าที่มากกว่า 0
o ตัวอย่างเช่น สมมติ s1 = ABA และ s2 = AAB เมื่อใช้ฟังก์ชัน memcmp เปรียบเทียบค่าของ s1 กับ s2 แล้ว
ผลลัพธ์ที่ได้จะมีค่ามากกว่า 0 เนื่องจาก s1 > s2 กล่าวคือ ฟังก์ชัน memcmp จะเริ่มเปรียบเทียบค่าที่ s1 ชี้อยู่กับ
ค่า s2 ชี้อยู่ทีละตัว โดยตัวแรกที่ s1 กับ s2 ชี้อยู่ คือตัวอักษร A เหมือนกัน จึงไปเปรียบเทียบตัวอักษรที่สองที่ s1
กับ s2 ชี้ต่อไป โดยตัวอักษรที่สองที่ s1 ชี้อยู่ คือ B และตัวอักษรที่สองที่ s2 ชี้อยู่คอื A จะพบว่าค่าตัวอักษร
ไม่เท่ากัน โดย B มีค่าเท่ากับ 66 และ A มีค่าเท่ากับ 65 (คือค่าได้จากแอสกี) ดังนั้น B จึงมากกว่า A และ
สรุปได้ว่า s1 > s2 ซึ่งหากใช้ฟังก์ชัน memcmp เปรียบเทียบค่าของ s1 กับ s2 ก็จะได้ผลลัพธ์เป็นค่าที่มากกว่า 0

รูปแบบ int memcmp(const void *s1, const void *s2, size_t n);
 ฟังก์ชันที่มีการประกาศไว้ในเฮดเดอร์ไฟล์ string.h
• ฟังก์ชัน void *memchr()
o จะทำการค้นหาบัฟเฟอร์ว่ามีค่าพารามิเตอร์ c อยู่หรือไม่
o หากพบพารามิเตอร์ c จะคืนค่าแอดเดรส ณ ตำแหน่งของพารามิเตอร์ c กลับมาให้
o แต่หากไม่พบก็จะคืนค่า Null Pointer กลับมาให้
รูปแบบ void *memchr(const void *s, int c, size_t n);
• ฟังก์ชัน void *memset()
o ทำการคัดลอก (Copy) ค่าของ c ลงไปยังหน่วยความจำ ณ ตำแหน่งที่ชี้อยู่
โดย s ซ้า ๆ กันจำนวน n ไบต์
รูปแบบ void *memset(void *s, int c, size_t n);
 ฟังก์ชันที่มีการประกาศไว้ในเฮดเดอร์ไฟล์ string.h
ตัวอย่าง โปรแกรมแสดงการทำงานของฟังก์ชันมาตรฐาน strchr() และ strstr()
1 #include <stdio.h>
2 #include <string.h>
ผลลัพธ์ของโปรแกรม
3
4 main()
5 {
6 char str[]="Hello ! C Language";
7 char substr[]="C Lan";
8
9 printf("String is %s\n", str);
10 printf("After use strchr(); with character \"!\" , ");
11 printf("String is %s\n", strchr(str, '!'));
12 printf("After search string with substr \"C Lan\" , ");
13 printf("String is %s\n", strstr(str, substr));
14 }
 ฟังก์ชันที่มีการประกาศไว้ในเฮดเดอร์ไฟล์ string.h
อธิบายโปรแกรม

• บรรทัดที่ 11 ใช้ฟังก์ชัน strchr() เพื่อค้นหาสตริงที่อยู่ต่อจากตัวอักษร "!“

คือ จะได้ค่าสตริง "! C Language“ ออกมา
• บรรทัดที่ 13 ใช้ฟังก์ชัน strstr() เพื่อค้นหา Substring "C Lan“
ในสตริง “Hello ! C Language“ จึงได้ผลลัพธ์เป็นสตริง "C Language“
 ฟังก์ชันที่มีการประกาศไว้ในเฮดเดอร์ไฟล์ string.h
ตัวอย่าง โปรแกรมแสดงการทำงานของฟังก์ชันมาตรฐานที่ทำงานเกี่ยวกับหน่วยความจำ
1 #include <stdio.h> 15 ch = (char *)memcpy(str1, str2, strlen(str2));
2 #include <string.h> 16 printf("********** memcpy(); **********\n");
3 17 if(ch)
4 main() 18 printf("Now !!! str1 is %s\n\n", str1);
5 { 19 else
6 char str1[] = "Prolog Language"; 20 printf("Cannot copy string with memcpy\n\n");
7 char str2[] = "Pascal Language"; 21
8 char str3[] = "Prolog Language"; 22 ch = (char *)memmove(str1, str3, strlen(str3));
9 char *ch; 23 printf("********** memmove(); **********\n");
10 int ret; 24 if(ch)
11 25 printf("Now !!! str1 is %s\n\n", str1);
12 printf("str1 is %s\n", str1); 26 else
13 printf("str2 is %s\n", str2); 27 printf("Cannot copy string with memmove\n\n");
14 printf("str3 is %s\n\n", str3);
 ฟังก์ชันที่มีการประกาศไว้ในเฮดเดอร์ไฟล์ string.h
28 ret = memcmp(str1, str2, strlen(str1));
29 printf("********** memcmp(); **********\n");
30 printf("Compare str1 with str2 , return value = %d\n", ret);
31 printf("str1 is %s str2\n",(ret==0) ? "equal" : "not equal");
32 ret = memcmp(str1,str3,strlen(str1));
33 printf("Compare str1 with str3 , return value = %d\n", ret);
34 printf("str1 is %s str3\n\n",(ret==0) ? "equal" : "not equal");
35
36 ch = (char *)memchr(str1, 'l’, strlen(str1));
37 printf("********** memchr(); **********\n");
38 printf("Search str1 with \'l\' Character , Result is %s\n\n", ch);
39
40 memset(str1, 'C’, 6);
41 printf("********** memset(); **********\n");
42 printf("Now !!! str1 is set to %s\n", str1);
43 }
 ฟังก์ชันที่มีการประกาศไว้ในเฮดเดอร์ไฟล์ string.h
ผลลัพธ์ของโปรแกรม
 ฟังก์ชันที่มีการประกาศไว้ในเฮดเดอร์ไฟล์ string.h
อธิบายโปรแกรม
• บรรทัดที่ 15 ทำการคัดลอก (Copy) ข้อมูลจาก str2 ลง str1
• บรรทัดที่ 22 ทำการคัดลอก (Copy) ข้อมูลจาก str3 ลง str1
• บรรทัดที่ 28 เปรียบเทียบ str1 คือ Prolog Language กับ str2 คือ Pascal
Language ด้วยฟังก์ชัน memcmp จะพบว่าตัวอักษรตัวแรกที่ str1 กับ str2 ชี้อยู่
มีค่าเท่ากัน จึงไปพิจารณาตัวอักษรตัวที่สองต่อไป ซึ่งพบว่าตัวอักษรตัวที่สองที่ str1
ชี้อยู่ คือตัวอักษร r และตัวอักษรที่สองที่ str2 ชี้อยู่คือตัวอักษร a โดย str1 > str2
ผลลัพธ์ที่ได้จึงมีค่ามากกว่า 0 (ผลลัพธ์ที่ได้จะมาจากการนำค่าของตัวอักษร r
ลบด้วยค่าของตัวอักษร a จะได้ 114-97 = 17) และเปรียบเทียบ str1
คือ Prolog Language จะพบว่าผลที่ได้คือ 0 แสดงว่า str1 เท่ากับ str3
 ฟังก์ชันที่มีการประกาศไว้ในเฮดเดอร์ไฟล์ string.h
อธิบายโปรแกรม

• บรรทัดที่ 36 ทำการค้นหาในบัฟเฟอร์ว่ามีตัวอักษร l อยู่หรือไม่ ถ้าค้นพบตัวอักษร l

ก็จะคืนค่าแอดเดรส ณ ตำแหน่งตัวอักษร l กลับมาให้ ดังนั้น เมื่อสั่งพิมพ์ข้อมูล
จึงได้คำว่า Log Language แสดงออกมา
• บรรทัดที่ 40 ทำการคัดลอก (Copy) ตัวอักษร C ลงในหน่วยความจำ ณ ตำแหน่ง
ที่ชี้อยู่โดย str1 เป็นจำนวน 6 ตัวอักษร