Transcript ฟังก์ชัน (Function) - โรงเรียนมหิดลวิทยานุสรณ์

โดย อ.ศิรพิ ร ศักดิ ์บุญญารัตน์
สาขาวิชาคอมพิวเตอร์และเทคโนโลยี โรงเรียนมหิดลวิทยานุสรณ์
เนื ้อหา
 ความหมายของฟั งก์ชน
ั และฟั งก์ชนั มาตรฐานของภาษาซี
 โครงสร้างของฟั งก์ชน
ั
 ประเภทของฟั งก์ชน
ั


ฟังก์ชนั แบบไม่มีการรับและส่ งค่าพารามิเตอร์
ฟังก์ชนั แบบมีการส่ งค่าพารามิเตอร์
 การประกาศรู ปแบบฟั งก์ชน
ั (Functions prototype)
 การเรี ยกใช้ฟังก์ชน
ั ในโปรแกรม
 วิธีการส่ งค่าพารามิเตอร์ ไปยังฟั งก์ชน
ั


แบบกาหนดค่า (pass by value)
แบบอ้างอิง (pass by reference)
 ฟั งก์ชน
ั เรี ยกตัวเอง
ผลการเรี ยนรู้ที่คาดหวัง
 อธิบายความหมายของฟังก์ชนั ได้
 อธิบายความหมายของฟังก์ชนั มาตรฐานของภาษาซีได้
 เขียนโปรแกรมประกาศฟังก์ชนั แบบไม่มีการส่ งค่าพารามิเตอร์และเรี ยกใช้งานได้
 เขียนโปรแกรมประกาศฟังก์ชนั แบบมีการส่ งค่าพารามิเตอร์กลับและเรี ยกใช้งานได้
 เขียนโปรแกรมประกาศฟังก์ชนั แบบมีการส่ งค่าพารามิเตอร์ไปยังฟังก์ชนั ด้วยวิธีการ
ส่ งค่าแบบกาหนดค่า(pass by value) และการส่ งค่าแบบอ้างอิง(pass by reference) ได้
 เขียนโปรแกรมแก้ปัญหาโจทย์ที่กาหนดให้โดยใช้ฟังก์ชนั เรี ยกตัวเอง(recursive) ได้
 เปรี ยบเทียบหลักการเขียนโปรแกรมเพื่อแก้ปัญหาโดยใช้การวนซ้ าและฟังก์ชนั เรี ยก
ตัวเองได้
4.1 ฟั งก์ชนั
ฟั งก์ชนั หรื อโปรแกรมย่อย (Function) ในการเขียนโปรแกรม
คอมพิวเตอร์ บ่อยครั้งจะต้องมีชุดคาสั่งบางชุดที่จะต้องถูกทางานบ่อยๆ
ถ้าหากโปรแกรมต้องทาชุดคาสัง่ เหล่านั้นอีกครั้งผูเ้ ขียนโปรแกรมจะต้อง
เขียนชุดคาสั่งชุดเดิมใหม่อีกครั้งทาให้โปรแกรมมีขนาดใหญ่ข้ ึน แต่เรา
สามารถนาชุดคาสั่งที่จะต้องถูกใช้งานบ่อย ๆ มารวมเป็ นฟั งก์ชนั ได้ แล้ว
จึงเรี ยกใช้ชื่อฟังก์ชนั แทนการที่จะต้องเขียนชุดคาสัง่ นั้นใหม่อีกครั้ง
ประเภทของฟั งก์ชนั แบ่งตามที่มาของฟั งก์ชนั
 แบ่ งเป็ น 2 ประเภทคือ
1) ฟั งก์ชน
ั มาตรฐาน (Standard Function) เป็ นฟังก์ชนั ที่ถูกสร้างขึ้น
และเก็บไว้ในไลบรารี ในการใช้งานเราต้องเรี ยกใช้ include
directives เพื่อเรี ยก header file ขึ้นมาก่อนจึงจะสามารถใช้งาน
ฟังก์ชนั นั้นได้
2) ฟั งก์ชน
ั ที่ผเู ้ ขียนโปรแกรมสร้างขึ้นเอง (User-defined Function)
เป็ นฟังก์ชนั หรื อโปรแกรมย่อยที่ผใู ้ ช้สร้างขึ้นมาใช้ในการเขียน
โปรแกรมเพื่อทางานอย่างใดอย่างหนึ่ง
จงอภิปราย
จงบอกชือ่ ฟงั ก์ชนั มาตรฐานในภาษาซี ที่
นักเรียนรูจ้ กั อย่างน้อย 10 ฟงั ก์ชนั
จงอภิปราย
จงพิจารณาบางส่วนโปรแกรมต่อไปนี้ ตาแหน่ งใดคือฟั งก์ชนั ที่ผใ้ ู ช้สร้างขึน้ เอง
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
void main()
{ int z;
z = sum(5,7);
printf(“ z=%d ”, z);
}
int sum(int x , int y)
{
int a;
a = x + y;
return(a);
}
การเรี ยกใช้ ฟังก์ ชัน
sum
ฟั งก์ ชันที่ผ้ ใู ช้ สร้ างขึน้
ชื่ อฟั งก์ ชัน sum
ฟั งก์ชนั มาตรฐาน
 เป็ นฟังก์ชนั ที่ผผู ้ ลิตคอมไพล์เลอร์เขียนขึ้นเพื่อให้ผใู ้ ช้นาไปใช้ในการ
เขียนโปรแกรมเพื่อให้เขียนโปรแกรมได้สะดวกและง่ายขึ้น
 บางครั้งอาจเรี ยกว่า library functions
 ปกติฟังก์ชนั เหล่านี้จะจัดเก็บไว้ใน header files ดังนั้นผูใ้ ช้จะต้องรู ้วา่
ฟังก์ชนั นั้นอยูใ่ น header file ใด จึงจะนาไปเรี ยกใช้ในส่ วนต้นของ
โปรแกรมด้วย #include <header file.h> เช่น #include <stdio.h>
 ฟังก์ชนั มีมากมาย เช่น ฟังก์ชนั ทางคณิ ตศาสตร์ ฟังก์ชนั ที่จดั การเกี่ยวกับ
ตัวอักษร
ฟั งก์ชนั ทางคณิตศาสตร์
 เป็ นฟั งก์ชัน ที่ ใ ช้ท างการค านวณ ทางคณิ ต ศาสตร์ ปกติ อ ยู่ใ น
math.h ผลลัพธ์ ที่ได้จากฟังก์ชนั กลุ่มนี้ เป็ นข้อมูลประเภท double
ดังนั้นตัวแปรที่ใช้จึงเป็ นพวกที่มีชนิดเป็ น double
 ฟั งก์ชน
ั sin(x) เป็ นฟังก์ชนั ใช้คานวณหาค่าของ sine โดย x
มีค่าของมุมในหน่วย เรเดียน
 ฟั งก์ชน
ั cos(x) ใช้หาค่า cosine โดย x มีหน่วยเป็ นเรเดียน
(radian)
ตัวอย่างที่ 4.1 การใช้ฟังก์ชนั ทางคณิ ตศาสตร์ คือ sin(), cos(), tan()
1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h>
#include <math.h>
main()
{
float deg , angle, pi = 3.141592654;
printf("\n\tPlease enter value of angle in degree \n\tthat
you want to find tan cos sin :");
scanf("%f",&deg);
angle = deg * pi / 180; /* เปลีย่ นค่า องศา ให้เป็ นเรเดียน */
printf("\n\tvalue of tangent %4.0f degree is %4.2f ",deg,tan(angle));
printf("\n\tvalue of sine %4.0f degree is %4.2f ",deg,sin(angle));
printf("\n\tvalue of cosine %4.0f degree is %4.2f ",deg,cos(angle));
}
ผลลัพธ์ ของโปรแกรม
ตัวอย่างที่ 4.2 การใช้ฟังก์ชนั ทางคณิ ตศาสตร์ บางฟังก์ชนั
#include <stdio.h>
#include <math.h>
main()
{
double x = 10.0 , y = 2.0 ,z = 16.0,a = 2.718282 ,
b = -2.718282 , m=1.0;
printf("\n\tpow(x,y) = %4.2f when x=10.0 y=2.0", pow(x,y));
printf("\n\tsqrt(z) = %4.2f when z=16.0", sqrt(z));
printf("\n\texp(m) = %4.6f when m=1.0",exp(m));
printf("\n\tlog(a) = %4.2f when a=2.718282",log(a));
printf("\n\tlog10(x) = %4.2f when x=10.0",log10(x));
printf("\n\tceil(a) = %4.2f when a=2.718282",ceil(a));
printf("\n\tceil(b) = %4.2f when b=-2.718282",ceil(b));
printf("\n\tfloor(a) = %4.2f when a=2.718282",floor(a));
printf("\n\tfloor(b) = %4.2f when b=-2.718282",floor(b));
printf("\n\tfabs(a) = %4.6f when a=2.718282" ,fabs(a));
printf("\n\tfabs(b) = %4.6f when b=-2.718282" ,fabs(b));
}
ตัวอย่างที่ 4.2 การใช้ฟังก์ชนั ทางคณิ ตศาสตร์ บางฟังก์ชนั
ผลลัพธ์ ของโปรแกรม
ฟั งก์ชนั ที่จดั การเกี่ยวกับตัวอักษร
 เป็ นฟังก์ชนั ที่จดั การกับตัวอักษร single char เท่านั้น ตัวอักษรนี้ใช้หน่วยความจา
เพียง 1 ไบต์ ฟังก์ชนั เหล่านี้อยูใ่ น header file ชื่อ ctype.h ก่อนจะทาการเขียน
โปรแกรมจึงต้อง #include <ctype.h> เข้ามาในส่ วนต้นของโปรแกรม เช่น
 ฟั งก์ชน
ั islower(cha) ฟังก์ชนั ที่ใช้ตรวจสอบว่าตัวอักขระในตัวแปร cha เป็ นตัวพิมพ์
เล็กหรื อไม่ ถ้าเป็ นตัวพิมพ์เล็กฟังก์ชนั จะส่ งค่ากลับเป็ นจานวนเต็มที่ไม่ใช่ 0 แต่ถา้ ไม่ใช่
ตัวพิมพ์เล็กจะส่ งค่ากลับเป็ น 0
 ฟั งก์ชน
ั isupper(cha) ฟังก์ชนั ที่ใช้ตรวจสอบว่าตัวอักขระในตัวแปร cha เป็ นตัวพิมพ์
ใหญ่หรื อไม่ ถ้าเป็ นตัวพิมพ์ใหญ่ ฟังก์ชนั จะส่ งค่ากลับเป็ นจานวนเต็มที่ไม่ใช่ 0 แต่ถา้
ไม่ใช่ตวั พิมพ์ใหญ่จะส่ งค่า 0
 ฟั งก์ชน
ั tolower(cha) ฟังก์ชนั ที่ใช้เปลี่ยนตัวพิมพ์ใหญ่ที่เก็บอยูใ่ นตัวแปรให้เป็ น
ตัวพิมพ์เล็ก
4.2 โครงสร้ างของฟั งก์ชนั
type function_name(type parameter [,type parameter]);
{
local varilabel declarations;
statement_1;
statement_2;
...
statement_N;
return(value);
}
ตัวอย่างที่ 4.4 การสร้างฟังก์ชนั sum
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
void main()
{ int z;
z = sum(5,7);
printf(“ z=%d ”, z);
}
int sum(int x , int y)
{
int a;
a = x + y;
return(a);
}
การเรี ยกใช้ ฟังก์ ชัน
sum
ฟั งก์ ชันที่ผ้ ใู ช้ สร้ างขึน้
ชื่ อฟั งก์ ชัน sum
4.3 ประเภทของฟั งก์ชนั
 ถ้าพิจารณาจากลักษณะการส่ งการรับข้อมูลระหว่างฟังก์ชนั กับตาแหน่งที่
เรี ยกใช้ฟังก์ชนั จะแบ่งฟังก์ชนั เป็ น 4 ประเภท คือ
1. ฟังก์ชน
ั ที่ไม่มีการรับการส่ งค่าใด ๆ
2. ฟังก์ชน
ั ที่ตอ้ งรับค่า parameter เข้าในการทางานในฟังก์ชนั แต่ไม่มีการ
ส่ งค่าใด ๆ กลับไปให้แก่ตาแหน่งที่เรี ยกใช้
3. ฟังก์ชน
ั ที่ไม่มีการรับค่าใดจากการเรี ยกใช้ แต่มีการส่ งค่ากลับไปให้แก่
ตาแหน่งที่เรี ยกใช้
4. ฟังก์ชน
ั ที่ตอ้ งรับค่า parameter เข้ามาในการทางานและส่ งค่ากลับไปให้
ตาแหน่งที่เรี ยกใช้
4.3.1 ฟั งก์ชนั ที่ไม่มีการรับและส่งค่า
void function_name(void)
function_name()
{
{
local variable declaration;
หรือ
local variable declaration;
statements;
}
statements;
}
ตัวอย่างที่ 4.5 ฟั งก์ชนั ที่ไม่มีการรับและส่งค่า
1 void sum()
2 { int num1,num2,result;
3
printf("input no.1 = ");
4
scanf(" %d ",&num1);
5
printf("input no.2 = ");
6
scanf(" %d ",&num2);
7
result = num1+num2;
8
printf(" sum = %d ",result);
9 }
4.3.2 ฟั งก์ชนั ที่มีการรับค่าและไม่มีการส่งค่ากลับ
void function_name(type parameter [,type parameter]);
{
local variable declaration;
statements;
}
ตัวอย่างที่ 4.6 ฟั งก์ชนั ที่มีการรับค่าและไม่มีการส่งค่ากลับ
1 void sum( int x , int y )
2 {
int result;
3
result = x+y;
4
printf(“%d”,result);
5 }
4.3.3 ฟังก์ชนั ที่ไม่มีการรับค่าแต่มีการส่ งค่ากลับ
type function_name(void);
type function_name()
{
{
local variable declaration;
หรือ
local variable declaration;
statements;
}
statements;
}
ตัวอย่างที่ 4.7 ฟังก์ชนั ที่ไม่มีการรับค่าแต่มีการส่ งค่ากลับ
1 float func1()
2 {
3
int x = 5, y = 2, z;
4
z = x / y;
5
return (z);
6 }
4.3.4 ฟังก์ชนั ที่มีการรับค่าและส่ งค่ากลับ
type function_name(type parameter [,type parameter]);
{
local variable declaration;
statements;
}
ตัวอย่ างที่ 4.8 ฟังก์ชนั ที่มีการรับค่าและส่ งค่ากลับ
1 int sqr(int x)
2 {
3
return (x * x);
4 }
4.4 การประกาศรู ปแบบฟังก์ชนั (Function Prototype)
type function_name(type parameter [,type parameter]);
หรือ
type function_name(type [,type]);
 ฟังก์ชนั ที่ผใู ้ ช้สร้างขึ้นจะต้องเขียนไว้ก่อนฟังก์ชนั main() โปรแกรมจึง
จะใช้งานฟังก์ชนั นั้นๆ ได้ แต่ถา้ ไม่เขียนไว้ก่อนฟังก์ชนั main() จะต้องมี
การประกาศรู ปแบบหรื อต้นแบบของฟังก์ชนั นั้นๆ ไว้ก่อนมีการเรี ยกใช้
ฟังก์ชนั นั้น ในฟังก์ชนั main()
4.5 การเรี ยกใช้ฟังก์ชนั ในโปรแกรม
 การเรี ยกใช้ฟังก์ชนั ขึ้นกับประเภทของฟังก์ชนั แต่มีโครงสร้างหลักดังนี้
1)ฟังก์ชนั ที่ไม่มีการรับส่ งค่าพารามิเตอร์ ทาดังนี้
function_name();
2)ฟังก์ชนั ที่มีการรับค่าพารามิเตอร์แต่ไม่มีการส่ งคืนค่า มีการเรี ยกใช้
ดังนี้
function_name(argument list);
โดย argument list คือ ตัวแปร หรื อนิพจน์ที่ส่งไปให้ฟังก์ชนั ถ้ามี
มากกว่า 1 ค่า ให้คนั่ ด้วยเครื่ องหมาย คอมม่า (,)
4.5 การเรี ยกใช้ฟังก์ชนั ในโปรแกรม (ต่อ)
3)ฟังก์ชนั ที่มีการรับค่าพารามิเตอร์และส่ งคืนค่า มีการเรี ยกใช้ ดังนี้
variable_name = function_name(argument list);
4)ฟังก์ชนั ที่ไม่มีการรับค่าพารามิเตอร์แต่มีการส่ งคืนค่า มีการเรี ยกใช้
ดังนี้
variable_name = function_name();
โดย variable_name คือ ชื่อของตัวแปรที่จะมารับค่าของฟังก์ชนั ที่
ส่ งคืนมา
ตัวอย่ างที่ 4.9 การเรียกใช้ ฟังก์ ชันประเภทที่มีการรับและ
ส่ งคืนค่ าพารามิเตอร์
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include<stdio.h>
#include<conio.h>
int sum( int x , int y );
//การประกาศ prototype
void main()
{
int num1,num2,net;
printf("input no.1 = ");
scanf("%d",&num1);
printf("input no.2 = ");
scanf("%d",&num2);
net = sum(num1,num2); //การเรี ยกใช้ฟังก์ชน
ั sum
printf("sum = %d",net);
}
int sum( int x , int y )
{
int s_sum;
s_sum = x+y;
return s_sum;
}
ค ำอธิ บำย ตั ว อย่ า งที ่ 4.9
บรรทัด ที ่ 10 เรีย กใช้ฟ งั ก์ช ัน
sum โดยมีพารามิเตอร์ทสี ่ ่งไป
ยังฟงั ก์ชนั 2 จานวนคือ num1
และ num2 และฟงั ก์ชนั sum มี
พารามิเตอร์ x และ y รอรับค่า
4.6 วิธีการส่ งค่าอาร์กเู มนต์ไปยังฟังก์ชนั
 การส่ งผ่านอาร์ กเู มนต์ไปให้ฟังก์ชนั ทาได้ 2 วิธีคือ
1. ส่ งผ่านโดยค่า (pass by value)
2. ส่ งโดยการอ้างอิง (pass by reference)
4.6 วิธีการส่ งค่าอาร์กเู มนต์ไปยังฟังก์ชนั
1. ส่ งผ่านโดยค่า (pass by value)
สาหรับวิธีน้ ี พารามิเตอร์ ที่ฟังก์ชนั ผูเ้ รี ยกส่ งไปจะถูกคัดลอกไปไว้
ในพื้นที่หน่วยความจาของฟังก์ชนั ที่ถูกเรี ยก
ถ้าฟั งก์ชนั ที่ถกู เรี ยกมีการ
เปลี่ยนแปลงค่าของพารามิเตอร์ เหล่านี้จะไม่มีกบั ค่าดั้งเดิมในฟั งก์ชนั ผูเ้ รี ยก
ตัวอย่างที่ 4.10 การส่ งอาร์กเู มนต์ผา่ นโดยค่า
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include<stdio.h>
#include<conio.h>
void markline(int y);
// prototype
void main()
{ int x=20;
markline(10); /*การเรียกฟงั ก์ชนั โดยวิธ ี 4.6.1 แบบกาหนดค่าคงทีไ่ ปทางาน*/
printf(“Function Main \n”);
markline(x); /*การเรียกฟงั ก์ชนั โดยวิธ ี 4.6.1 แบบกาหนดส่งตัวแปร x ไปทางาน */
}
/*Function call by value */
void markline(int y)
{ int i;
for(i=0; i<=y; i++)
printf(“-”);
printf(“\n”);
}
4.6 วิธีการส่ งค่าอาร์กเู มนต์ไปยังฟังก์ชนั
2. ส่ งโดยการอ้างอิง (pass by reference)
ซึง่ เป็ นการส่งค่าตาแหน่งในหน่วยความจาทีเ่ ก็บค่าพารามิเตอร์ในฟงั ก์ชนั
ผูเ้ รียกไปให้กบั ฟงั ก์ชนั ทีถ่ กู เรียก ถ้าฟงั ก์ชนั ทีถ่ กู เรียกทาการเปลีย่ นแปลง
ค่าของพารามิเตอร์เหล่านี้ การเปลีย่ นแปลงจะถูกกระทาโดยตรงใน
หน่วยความจาทีต่ าแหน่งของพารามิเตอร์ทส่ี ง่ ไป ดังนัน้ การเรียกใช้
ฟงั ก์ชนั และส่งค่าไปให้กบั ฟงั ก์ชนั แบบการส่งผ่านโดยการอ้างอิงนี้ ค่าตัว
แปรทีฟ่ งั ก์ชนั ผูเ้ รียกส่งไปเป็ นพารามิเตอร์จะถูกเปลีย่ นค่าไปได้ ตามคาสัง่
ในฟงั ก์ชนั ทีถ่ กู เรียก
ตัวอย่างที่ 4.11 การส่ งอาร์กเู มนต์ผา่ นโดยค่า
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <stdio.h>
void divide(float , int );
main()
{
float x; int y;
printf("\n\tPlease type 1st number that you want to know the division : ");
scanf("%f",&x);
printf("\n\tPlease type 2nd number that you want to know the division : ");
scanf("%d",&y);
printf("\n\tBefore the function work x = %f y = %d ",x,y);
divide(x,y);
/* ส่งค่า x,y ไปให้ ฟงั ก์ชนั divide(float p, int q) */
printf("\n\tAfter the function work x = %f y = %d ",x,y);
getch();
}
void divide(float p, int q)
{
float k;
k = p/q;
printf("\n\tInside function p=%4.2f q=%d p/q =%4.2f \n",p,q,k);
}