วันพุธที่ 17 กันยายน พ.ศ. 2557

06:52
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  */
  
ผลลัพธ์ที่ได้จากโปรแกรม

แผนผังลำดับงาน: จอภาพ: A = 5,  B = 7  P = 8.000,  Q = 3.500    Press any key back to program…
คำอธิบายโปรแกรม 
            จากโปรแกรมตัวอย่างที่ 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  */
ผลลัพธ์ที่ได้จากโปรแกรม

แผนผังลำดับงาน: จอภาพ: Return Maximum Value is…45
คำอธิบายโปรแกรม 
            จากโปรแกรมตัวอย่างที่ 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  */

ผลลัพธ์ที่ได้จากโปรแกรม

แผนผังลำดับงาน: จอภาพ: ***********************************************  ****** C and C++ PROGRAMMING ******  ***********************************************    Press any key back to program…    

คำอธิบายโปรแกรม 
            จากโปรแกรมตัวอย่างที่ 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  */
ผลลัพธ์ที่ได้จากโปรแกรม

แผนผังลำดับงาน: จอภาพ: P = 3 Q = 5 K = 8  P = 6.500 Q = 11.000 K = 4.500  P = 5 Q = 6.500 K = 32.500  P = 18.00 Q = 3 K = 6.00    Press any key back to program…
คำอธิบายโปรแกรม 
            จากโปรแกรมตัวอย่างที่ 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  */
ผลลัพธ์ที่ได้จากโปรแกรม

แผนผังลำดับงาน: จอภาพ: Array #1 = 100  Array #2 = 200  Array #3 = 300  Array #4 = 400  Array #5 = 500    Press any key back to program…

คำอธิบายโปรแกรม 
            จากโปรแกรมตัวอย่างที่ 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  */
ผลลัพธ์ที่ได้จากโปรแกรม

แผนผังลำดับงาน: จอภาพ: P = 3,  Q = 4,  R = 7    Press any key back to program…
คำอธิบายโปรแกรม 
            จากโปรแกรมตัวอย่างที่ 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  */
ผลลัพธ์ที่ได้จากโปรแกรม

แผนผังลำดับงาน: จอภาพ: P = 50,  Q = 100  P = 100,  Q = 50  P = 50,  Q = 100    Press any key back to program…

คำอธิบายโปรแกรม 
            จากโปรแกรมตัวอย่างที่ 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  */
ผลลัพธ์ที่ได้จากโปรแกรม

แผนผังลำดับงาน: จอภาพ: A = 15,  B = 20,  C = 25    Press any key back to program…
คำอธิบายโปรแกรม 
            จากโปรแกรมตัวอย่างที่ 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  จะกลับเข้าสู่โปรแกรม

0 ความคิดเห็น:

แสดงความคิดเห็น