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

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

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

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

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