back to main...

ฟังก์ชันที่ผู้ใช้เขียนขึ้นเอง

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

รูปแบบของฟังก์ชัน

       type function-name(type arg1, type arg2,..., type  argn)
       {
	   local Variable;
	   .
	   .
	   statement;
	   .
	   .
	   .
	   return(value);
       }
	

typeชนิดของฟังก์ชันซึ่งจะมีผลต่อค่าที่ส่งกลับไปยังฟังก์ชัน
ที่เรียกใช้ถ้าไม่กำหนดค่าส่งกลับจะเป็นชนิด int
function-nameชื่อของฟังก์ชัน
arg1,arg2,...argnเป็นค่าคงที่หรือตัวแปรที่ทำหน้าที่รับค่ามาทำงานในฟังก์ชัน
type arg1,...argnเป็นการประกาศชนิดของตัวแปรที่ทำหน้าที่รับค่ามาทำงานในฟังก์ชัน
returnเป็นคำสั่งที่บอกให้รู้ว่าการทำงานของฟังก์ชันเสร็จให้ส่งค่ากลับไปยังฟังก์ชันที่
เรียกได้
valueเป็นค่าที่จะส่งกลับไปยังฟังก์ชันที่เรียกโดยจะส่งค่ากลับไปโดยผ่านทางชื่อฟังก์ชัน
และจะส่งค่ากลับไปได้เพียงค่าเดียวโดยมีชนิดตามชนิดของชื่อฟังก์ชันที่ประกาศ
ไว้ในกรณีที่ฟังก์ชันไม่มีการส่งค่ากลับก็ไม่ต้องกำหนดค่า value หลังคำสั่ง return

ตัวอย่าง

	#include <stdio.h>
	float f1(int a,int b,char ch);
	void main(void)
	{
		float 	f1();
	   	int    	x,y;
	   	char 	st;
	   	float  	d;
	        	d=f1(x,y,st);
	}
  	float   	f1(int  a, int  b, char ch)
	{
	   .	
	   .	
	   .
	   return(sum);
	}

ชนิดของฟังก์ชัน


ฟังก์ชันที่เขียนขึ้นเองสามารถแบ่งให้เห็นชัดเจนได้เป็น 2 แบบ ใหญ่ ๆ คือ

1. ฟังก์ชันที่ไม่มีการส่งค่ากันระหว่างฟังก์ชัน

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

ตัวอย่าง

	#include <stdio.h>
	void markline(void);
	void main(void)
	{
 		markline();
		printf("FUNCTION TEST \n");
	   	markline(); 
	}
	void markline(void)
	{   
		int i,line=15;
		for(i=0;i<=line;i++)
	        		printf("-");
	        	printf("\n);
	}

2. ฟังก์ชันที่มีการส่งค่ากันระหว่างฟังก์ชัน

เป็นการเขียนฟังก์ชันในลักษณะที่มีการส่งค่ากันระหว่างฟังก์ชันที่เรียกใช้
กับฟังก์ชันที่ถูกเรียกซึ่งแบ่งเป็น

1. ฟังก์ชันที่ส่งค่าไปทำงานยังโปรแกรมที่ถูกเรียกใช้เพียงอย่างเดียวไม่มี
การส่งค่ากลับคืนมายังโปรแกรมที่เรียก ซึ่งมีลักษณะของการส่งค่ากันได้
หลายแบบ ดังนี้คือ

  • ส่งค่าไปยังฟังก์ชันที่ถูกเรียกใช้โดยส่งค่าของตัวแปรหรือค่าคงที่ไป
    โดยตรงซึ่งเรียกว่า call by Value
  • ตัวอย่าง

    	#include <stdio.h>
    	void markline(int l);
    	void main(void)
    	{ 
    		int a=20;
    	  	markline(15);
    	  	printf("FUNCTION TEST");
    	  	markline(a);
    	}
    	void markline(int l )
    	{ 
    	   	int i;
    	   	for(i=0;i<=1;i++)
    	      		printf("-");
    		printf("\n");
    	} 
    

    2. การส่งค่าไปยังฟังก์ชันที่ถูกเรียกใช้โดยส่งเป็นค่าตำแหน่งที่อยู่ของ
    ตัวแปรไป เรียกว่า cal by referance

    ตัวอย่าง

    	#include <stdio.h>
    	void swap(int *x, int *y);
    	void main(void)
    	{  
    		int x=10,y=20;
    	   	printf("x=%d y=%d\",x,y);
    	   	swap(&x,&y);
    	   	printf("x=%d y=%d \n",x,y);
    	}
    	void swap(int *x,int *y)
    	{  
    	   	int temp;
    	   	temp = *x;
    	   	*x=*y;
    	   	*y=temp;
    	}
    

    3. การส่งค่าไปยังฟังก์ชันที่ถูกเรียกใช้โดยส่งค่าที่เป็นตัวแปรชุดทั้งชุด
    ไปเรียกว่า Calling Function with Arrays ซึ่งสามารถทำได้ 3 วิธี คือ

  • มีการประกาศขนาดของตัวแปรชุดที่ทำหน้าที่ในการรับค่า

  • ตัวอย่าง

    	#include <stdio.h>
    	void display(int num[10]);
    	void main(void)
    	{
    		int t[10],i;
    		for (i=0;i<10;i++)
    			t[i]=i;
    		display(t);
    	}
    	void display(int num[10])
    	{  
    		int i;
    		for(i=0;i<10;i++)
    			printf("%d",num[i]);
    	}
    

  • ไม่ต้องมีการประกาศขนาดของตัวแปรชุดที่ทำหน้าที่ในการรับค่า เช่น

  • ตัวอย่าง

    	#include <stdio.h>
    	void display(int num[]);
    	void main(void)
    	{ 
    		int t[10],i;
    	     	for(i=0,i<10;i++)
    	        		t[i]=i;
    	     	display(t);
    	}
    	void display(int num[])
    	{ 
    		int i;
    	   	for(i=0;i<10;i++)
    	     		printf("%d",num[i]);
    	}
    

    3. ตัวแปรที่ทำหน้าที่รับค่าถูกกำหนดเป็นพอยน์เตอร์

    ตัวอย่าง

    	#include <stdio.h>
    	void display(int *num)
    	{
    		int i;
    	  	for(i=0;i<10;i++)
    	     		printf("%d",num[i]);
    	}
    

    3. ฟังก์ชันที่มีการส่งค่ากลับ

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

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

    ตัวอย่าง

    	#include <stdio.h>
    	float sqr(float x);
    	void main(void)
    	{  
    	   	float t=10;
    	       	printf("%f %f",t sqr(t));
    	}
    	float sqr(float x)
    	{
    	   	x=x *x;
    	   	return(x);
    	}
    

    การใช้ตัวแปรในเรื่องฟังก์ชัน

    1. ตัวแปรชนิด Automatic หรือบางทีเรียกว่า Local Variable
    เป็นตัวแปรที่ถูกกำหนดขึ้นภายในบล็อก (ภายในเครื่องหมาย { }) ของฟังก์ชัน
    ตัวแปรเหล่านี้จะมีผลเฉพาะในบล็อกที่มันอยู่เท่านั้น

    ตัวอย่าง

    	#include <stdio.h>
    	void main(void)
    	{
    	   	int i=5;
    	   	printf("I 1 = %d \n",i);
    	   	{
    	       		int i=0;
    	       		printf("I 2 = %d \n",i);
    	    	}
    	       	i++;
    	       	printf("I 1 = %d \n",i);
    	}
    

    จะเห็นว่าค่า i=0 จะมีผลอยู่ภายในบล็อกของตนเองเท่านั้น เมื่อออกจาก
    บล็อกมาทำค่า i++ จะใช้ค่า i=5 ซึ่งประกาศไว้ตอนต้นจึงทำให้ค่า I1 มีค่า
    เป็น 6

    2. ตัวแปรชนิด External หรือ บางทีเรียกว่า Global Variable
    เป็นตัวแปรที่สามารถใช้ร่วมกันได้ทุกฟังก์ชันในโปรแกรมเดียวกัน โดย
    ตัวแปรเหล่านี้จะถูกกำหนดไว้นอกจากฟังก์ชันใด ๆ

    ตัวอย่าง

    	#include <stdio.h>
    	void f1(void);
    	int a=5;
    	float n=12.57;
    	void main(void)
    	{
    	   	printf("%d &10.2f \n ",a,x);
    	       	a++;
    	       	x++;
    	       	f1();
    	}
    	void f1(void)
    	{
    	  	x++;
    	  	a++;
    	  	printf("%d %10.2f \n",a,x);
    	}
    

    จะเห็นได้ว่าตัวแปร a,x ซึ่งประกาศเป็นตัวแปร global นั้นจะมีผลในฟังก์ชัน
    ทุกฟังก์ชัน ดังนั้นเมื่อมีการเพิ่มค่า a,x ใน main จะได้ค่าเป็น 6 กับ 13.57
    พอมีการเรียกฟังก์ชัน f1 ก็จะส่งค่ามาทำงานใน โดยมาเพิ่มค่า x กับ a อีก
    อย่างละ 1 จึงกลายเป็น 7 กับ 14.57

    3. ตัวแปรชนิด Static

    เป็นตัวแปรที่มีลักษณะการทำงานเหมือนกับตัวแปร Automatic แต่เมื่อ
    ทำงานจนสิ้นสุดบล็อกแล้วค่าของตัวแปรชนิดนี้ยังคงอยู่ตัวแปรเหล่านี้จะ
    สามารถกำหนดได้ โดยใช้คำสั่ง staticนำหน้าชื่อตัวแปร

    ตัวอย่าง

    	#include <stdio.h>
    	void f1(void);
    	void main(void)
    	{ 
    	   	f1();
    	   	f1();
    	   	f1();
    	}
    	void f1(void)
    	{
    	   	int i=0;
    	   	static int s=5;
    	       	printf("I=%d s=%d \n",i,s);
    	   	i++;
    	   	s++;
    	}
    

    ใน มีการเรียกฟังก์ชัน f1 ใช้ซึ่งกำหนดให้ i=0 และ s=5 แล้วมีการเพิ่มค่า i
    อีก 1 s อีก 1 แล้วกลับไป main ซึ่งเรียก f1 อีกครั้งก็กลับมา set ให้ i=0
    เนื่องจาก i เป็นตัวแปร local ธรรมดาแต่ s มีค่าเป็น 6 เพราะตัวแปร static
    ยังคงค่าเดิมอยู่

    4. ตัวแปรชนิด Register

    การกำหนดชื่อตัวแปรจะเป็นการจองเนื้อที่ในหน่วยความจำเพื่อใช้ในการ
    เก็บข้อมูลต่าง ๆ ถ้ามีการเปลี่ยนแปลงแก้ไขข้อมูลในตัวแปรนั้นบ่อย ๆ
    จะเสียเวลาในการประมวลผลมากดังนั้นในภาษา C จึงสามารถให้เตรียมที่
    สำหรับตัวแปรไว้ในรีจิสเตอร์ได้ เพื่อให้ทำงานได้เร็วขึ้น และมักนิยม
    ใช้กับตัวแปรที่มีการเปลี่ยนแปลงค่าบ่อย ๆ เช่น ตัวแปรควบคุมวงจร
    ตัวแปรที่เก็บในรีจิสเตอร์จะถูกจำกัดด้วยชนิดของตัวแปร เนื่องจาก
    รีจีสเตอร์มีขนาดเล็กจึงสามารถใช้ตัวแปรได้บางชนิด เช่น int,char,pointer

    ตัวอย่าง

    	
    	register int i;
    	for(i=0;i<=2000;i++)
    	      	a[i]=0;
    

    back to main...