Docstoc

lesson5

Document Sample
lesson5 Powered By Docstoc
					!

                                           บทที่ 5
                                         ั
                                   ฟงกชน (Function)

♦! วามหมายและประโยชนของฟงกชน
 ค                            ั
         ฟงกชัน (Function) หมายถึง ประโยคคําสั่ง(statements) ชุดหนึ่งซึ่งมีชื่อเรียกใชโดยเฉพาะ
                                                           ่
ฟงกชันหนึ่ง ๆ จะทําหนาที่เฉพาะอยางใดอยางหนึ่ง สวนอืน ๆ ของโปรแกรมสามารถเรียกสเตตเมนต
ชุดนีได โดยการเรียกใช ชื่อฟงกชัน นัน ๆ ใหถูกตองตามรูปแบบที่ฟงกชันนั้น ๆ กําหนดไว
     ้                                 ้

         ฟงกชันในภาษา C++ มี 2 ประเภท คือ
                                              ั ่                      ้            ้
         1. User Defined Function คือ ฟงกชนทีผเู ขียนโปรแกรมสรางขึนหรือกําหนดขึนเอง ตามรูป
                                   ่
แบบการสรางฟงกชันของ C++ เพือนํามาใชในการเขียนโปรแกรมของตนเอง (จะกลาวถึงรายละเอียด
ตอไป)
         2. Standard Function คือ ฟงกชันมาตรฐานที่บริษัทผูสราง Compiler ภาษา C++ ไดสราง
                                                                 ั
รวบรวมไวในคลัง (Library) ผูเ ขียนโปรแกรมสามารถเรียกใชไดทนที ไดแก ฟงกชันที่ประกอบอยูใน
header file ตาง ๆ ขณะเรียกใช ตอง #include ชื่อไฟลที่รวบรวมฟงกชันนั้นไวกอน เชน ฟงกชัน
clrscr() ทําหนาที่ลางจอภาพใหวางและเลื่อน cursor ไปไวที่มุมซายบนของจอภาพ เปนฟงกชันอยูใน
ไฟล conio.h เปนตน

                    ั
        ประโยชนฟงกชนในการเขียนโปรแกรมใน C++ มีดังตอไปนี้
                                                  ้
        1. ชวยใหไมตองเขียน statement เดิม ๆ ซํากันหลายครั้งในโปรแกรมเดียวกัน
                                      ่              ่                           ่
        2. ชวยใหสามารถคนหาสวนทีผลหรือสวนทีตองปรับปรุงไดอยางรวดเร็ว เนืองจากเราทราบวา
แตละฟงกชันทําหนาที่อะไร และสรางฟงกชันไวที่สวนใดของโปรแกรม
        3. ทําใหโปรแกรมมีขนาดกระทัดรัด ทําความเขาใจไดงายและรวดเร็ว เพราะเขียนแบงเปน
      ั                   ่ ่ี 
ฟงกชนตามงานหรือหนาทีทตองการเขียน
        4. เนื่องจากฟงกชันมีการทํางานเปนอิสระ สามารถนําฟงกชันที่สรางไวและมีการทํางานเปน
มาตรฐานแลว เก็บไวใน Header File เพื่อใหเปนคลังคําสั่ง(Library) ของผูใช นําไปใชไดในโปรแกรม
  ่       ี ่                                            ้
อืน ๆ ไดอก ซึงชวยใหเราเขียนโปรแกรมใหมไดรวดเร็วขึน โดยการนําฟงกชันที่มีอยูแลวมาใชใหมได




ศิริชัย นามบุรี                                                                         ั
                                                                                  ฟงกชน(Functions)
!                                                  59

♦!สวนประกอบในการสรางฟงกชัน
          ฟงกชนทีเ่ ราสรางขึนเอง เรียกวา User Defined Function ซึ่งใน C++ กําหนดใหเมือมีการเรียก
                ั              ้                                                           ่
ใชชื่อฟงกชันใด ๆ จะตองมีการ สงคากลับมา (return value) ในชื่อฟงกชันนั้นเสมอ มีรปแบบโครง
                                                                                         ู
สรางของฟงกชันประกอบไปดวยสวนหัวของฟงกชันและสวนของ statement ดังนี้

            function_type function_name (parameter1,parameter2,…) //function header
            { int …        //declaration variable in function
              float …               //declaration variable in function
                  statement;                 //statement in function
                  statement;                 //statement in function
                 return(value); //function must return only one or null value to function_name
        }

        ความหมายของสวนประกอบในฟงกชัน มีดังนี้
                                                       ่
        function_type คือ ประเภทคาหรือขอมูลทีไดจากการทํางานของฟงกชัน ซึ่งจะตองใหคาคืน
กลับมาเก็บไวในชื่อของฟงกชัน (function_name) ถาเปนประเภท void จะเปนฟงกชันประเภทที่ตองมี
การ return value
                                                     ้                 ้ ่
        function_name คือ ชื่อฟงกชันที่กําหนดขึนตามกฎเกณฑการตังชือของ C++ และจะเปนชื่อที่ใช
สําหรับการเรียกใชฟงกชันตอไป
        (parameter1,parameter2,…) หรือพารามิเตอรประกอบไปดวย ประเภทและชื่อของตัวแปร
    ั            ่          ํ                                                     ํ
ใชรบคาคงทีเ่ พือนํามาใชทางานในฟงกชัน ในขณะที่ฟงกชันนั้นถูกเรียกใชทางาน พารามิเตอรของ
ฟงกชันมีมากกวา 1 ตัวและหลายประเภทได
                                                   
        return(value); โดยที่ return เปนคียเ วิรด และ value คือคาคงที่ที่สงคืนไปใหแกชื่อฟงกชัน 1
คาหรือไมมีก็ได ( กรณีเปนฟงกชันที่ไมใหคาใด ๆ)

            ตัวอยางการกําหนดชื่อฟงกชัน เชน




ศิริชัย นามบุรี                                                                               ั
                                                                                        ฟงกชน(Functions)
!                                                 60

                  int factorial(int number)
                                             parameter ของฟงกชันเปน integer
                                   ชื่อฟงกชัน factorial
                          ประเภทฟงกชันใหคาเปน integer

               ความหมาย คือ ฟงกชันชื่อ factorial() คาที่ไดจากการทํางานของฟงกชันเปน int และ
                                              ่ี ั
ขณะเรียกใชตองมีการรับคาพารามิเตอรมาเก็บไวทตวแปร number และเปนประเภท int เพื่อในมาใช
ภายในฟงกชัน

         void line()
                                                            ั ่ ี
                  ความหมายคือ ฟงกชันชื่อ line() เปนฟงกชนทีไมมพารามิเตอร เมื่อฟงกชันทํางาน
เสร็จแลว จะไมใหคาใด ๆ คืนกลับมา เพราะมีประเภทเปน void

        float power(int base, int exp)
                ความหมาย ฟงกชันชื่อ power() คาที่ไดจากฟงกชันเปน float และขณะเรียกใชตองมี
การรับคาพารามิเตอร 2 ตัว ตัวแรก base เปน int และตัวที่สอง exp เปน int มาใชในฟงกชันดวย



♦! ารสรางและการเรียกใชฟงกชนในโปรแกรม
 ก                        ั

                                   ั
           การสรางและการเรียกใชฟงกชนในโปรแกรม มีการกําหนดรูปแบบการสรางและเรียกใช ดังนี้




ศิริชัย นามบุรี                                                                              ั
                                                                                       ฟงกชน(Functions)
!                                                     61

           #include <header file>
           #include <header file>
           //declaration 2 prototype function in this program are line() and factorial()
           void line();
           int factorial(int number);

           void main()                //function main()
           { int …          //declaration variable in function main()
          statement;                  //statement in function
          factorial(int value or variable); //call function factorial() in function main()
             statement;               //statement in function
              line();          //call function line() in function main()
             statement;               //statement in function
         } //end of main() and end of this program

           void line()
            { int …         //declaration variable in function
           float …          //declaration variable in function
              statement;             //statement in function
              statement;             //statement in function
             } //return

           int factorial(int number)
            { int …         //declaration variable in function factorial()
          float …           //declaration variable in function factorial()
             statement;              //statement in function factorial()
            line();         //call function line() in function factorial()
             statement;              //statement in function factorial()
             return(value);//return only one value to factorial() function
         } //return


ศิริชัย นามบุรี                                                                                    ั
                                                                                             ฟงกชน(Functions)
!                                                   62

                                      ่ ี            ั
          จากโครงสรางโปรแกรมทีมการสรางฟงกชน สรุปไดดังนี้
                                                 ํ         ่ี                       ั
          1. การประกาศชื่อฟงกชันที่ผูใชกาหนดไวทตอนตนโปรแกรมกอนฟงกชน main() เรียกวา
ฟงกชันตนแบบ (prototype) หรือการกําหนดฟงกชัน (function declaration) แสดงวาในโปรแกรมมีการ
สรางและเรียกใชฟงกชันเหลานี้ ซึ่งสามารถเรียกใชชื่อฟงกชันนั้น ณ ตําแหนงใด ๆ ของโปรแกรมก็ได
                          ่ื      ั ้
ยกเวนหาม เรียกใชชอฟงกชนนันในตัวฟงกชนเอง     ั          การประกาศฟงกชันตนแบบ(prototype) ที่มี
พารามิเตอร(parameters) ทําได 2 ลักษณะ คือ
                                                       ั         ้
                    - ในสวนของพารามิเตอรของฟงกชน เขียนทังชนิดขอมูลและตัวพารามิเตอร เชน
                             int factorial(int number);
                                                         ั
                    - ในสวนของพารามิเตอรของฟงกชน เขียนเฉพาะชนิดขอมูล เชน
                             int factorial(int);
          2. การเรียกใชฟงกชันมีรูปแบบการเรียกใชเสมือนเปน statement เชน line() factorial(x) โดย
                                ํ
ที่ฟงกชันใดที่มีพารามิเตอรกาหนดไว ตองใสคา argument ใหถูกตองในขณะเรียกใชดวย และเรียก x
ของฟงกชัน factorial() วาอากิวเมนต (argument)
          3. เมื่อมีการเรียกใชฟงกชัน ณ ตําแหนงใด โปรแกรมจะไปทํางานในฟงกชันนั้นจนเสร็จ แลวจะ
กลับมาทํางานตอใน statement ถัดไปจากตําแหนงที่เรียกใชฟงกชัน
          4. สามารถเรียกใชฟงกชันกี่ครั้งก็ไดในโปรแกรม


♦! งกชนไมมพารามิเตอร
 ฟ ั       ี
                ั     ี
          ฟงกชนไมมพารามิเตอร หมายถึง ฟงกชันที่ไมมีการรับคาพารามิเตอรมาใชในขณะทํางาน
                                                               ั
และการเรียกใชก็ไมตองสง argument มาใหฟงกชัน อาจเปนฟงกชนประเภทคืนคา (return value) หรือ
ไมมีการคืนคาใด ๆ ใหแกชื่อฟงกชันเมื่อทํางานเสร็จก็ได
        •! ตัวอยางโปรแกรม line_non.cpp แสดงการสรางและเรียกใชฟงกชันแบบไมมพารามิเตอร
                                                                                  ี
             และไมมีการคืนคาใด ๆ คือ ฟงกชันประเภท viod

/*Program : line_non.cpp
 Process : creat non-parameter function line() */
#include <iostream.h>
#include <conio.h>
//declaration prototype function
void line();
//begin main program
void main()
{ int i;

ศิริชัย นามบุรี                                                                              ั
                                                                                       ฟงกชน(Functions)
!                                                   63

 clrscr();
 cout<< "Display 1 line from line() function\n";
 line(); //call line() and non-argument
 getch();
 cout<< "Display 5 lines from line() function\n";
 for (i=1;i<=5;++i)
   line(); //call line() and non-argument
 getch();
}//end main program
void line() //non-parameter function
{
  cout<< "_________________________________\n";
}

           •! ตัวอยางโปรแกรม func_non.cpp แสดงโปรแกรมที่มีการสรางฟงกชันประเภทที่ไมมี
              parameter ไมมการ return value คือ ฟงกชัน input() และฟงกชันที่ไมมี parameter
                             ี
                  ี
              แตมการ return value คือฟงกชัน summation()

/*Program : func_non.cpp
  process : display return value and non-parameter function
*/
#include <iostream.h>
#include <conio.h>
//prototype function declaration
int summation();
void input();
//global variable
int x,y;
void main()
{ clrscr();
  input(); //called function input()
  cout<<"Result of x+ y =\a"<<summation(); //called function summation()
  getch();
}

void input() //non-return value function
{ cout<<"Enter 2 number for summation : "<<endl<<endl;
  cout<<"Number1 : ";cin>>x;

ศิริชัย นามบุรี                                                                         ั
                                                                                  ฟงกชน(Functions)
!                                                  64

cout<<"Number2 : ";cin>>y;
}
int summation() //return value function
{ int result;
  result=x+y;
  return (result); //return result value to summation() called
}

♦! งกชนมีพารามิเตอร
 ฟ ั
                 ั
          ฟงกชนมีพารามิเตอร หมายถึงฟงกชันที่มีการรับคาพารามิเตอรมาใชในขณะฟงกชันทํางาน ดัง
นั้นการเรียกใชฟงกชันประเภทนี้ ตองสง argument มาใหฟงกชันดวย จึงจะสามารถทํางานได ดัง
ตัวอยาง
          •! ตัวอยางโปรแกรม line_par.cpp แสดงการสรางและเรียกใชฟงกชันแบบมีพารามิเตอรและ
               ไมมีการคืนคาใด ๆ (เปนฟงกชันประเภท void) ใหแกชื่อฟงกชัน ณ จุดเรียกใช คาที่ไดจาก
                                                                   ่
               การทํางานของฟงกชัน จะตองนําไปใชอยางใดอยางหนึงในโปรแกรม เชน แสดงคานั้นทาง
               จอภาพ เก็บคาที่ไดไวในตัวแปร เปนตน
/*Program : line_par.cpp
  Process : creat parameter function line()*/
#include <iostream.h>
#include <conio.h>
void line(int amount); //declaration prototype function
//begin main program
void main()
{ int i=45;
  //begin statement
  clrscr();
  cout<< "Display line from line() function\n";
  line(30); //call line() and send constant argument is 30
  getch();
  line(50); //call line() and send constant argument is 50
  getch();
  line(i); //call line() and send variable argument is i
  getch();
}
//end main program
void line(int amount) //amount is int parameter of function
{
  int x;

ศิริชัย นามบุรี                                                                                 ั
                                                                                          ฟงกชน(Functions)
!                                             65

    for(x=1; x<=amount;++x)
     cout<<"_";
    cout<<'\n';
}
         หมายเหตุ จากโปรแกรมตัวอยาง การกําหนดคาอารกวเมนต (argument) ในการเรียกใชฟงกชัน
                                                               ิ
ทําได 2 ลักษณะ คือ
                                                                                      ั
         1. กําหนดเปนคาคงที่ (constant) ใหเปนประเภทเดียวกันกับพารามิเตอรของฟงกชน เชน การ
เรียกใชฟงกชัน line(30) line(50) ซึ่ง 30 และ 50 คือ คาคงที่ชนิด int
         2. กําหนดเปนตัวแปร(variable) โดยกําหนดใหเปนตัวแปรประเภทเดียวกันกับพารามิเตอรของ
ฟงกชัน เชน การเรียกใชฟงกชัน line(i) ซึ่ง i เปนตัวแปรชนิด int

         •! ตัวอยางโปรแกรม func_par.cpp แสดงการคํานวณการบวก ลบ คูณ หาร เลข
             จํานวนจริง 2 จํานวน โดยการสรางฟงกชันประเภทที่มี parameters และมีการ
                                  ่ื     ั                        ั
             return value ใหแกชอฟงกชน ณ ตําแหนงทีเ่ รียกใชฟงกชน
/*Program : func_par.cpp
  process : display return value and parameter function
        calculate addition,subtract,multiply and divide
*/
#include <iostream.h>
#include <conio.h>
#include <iomanip.h>
//prototype function declaration
void input();
float addition(float x, float y);
float subtract(float x, float y);
float multiply(float x, float y);
float divide(float x, float y);
//global variable
float num1,num2;
void main()
{ clrscr();
  input();
 cout<<"Result of addition = "<<addition(num1,num2)<<endl;
 cout<<"Result of subtract = "<<subtract(num1,num2)<<endl;
 cout<<"Result of multiply = "<<multiply(num1,num2)<<endl;
 cout<<"Result of subtract = "<<divide(num1,num2)<<endl<<endl;
 cout<<"Calculate by sent argument to parameters of function..."<<endl;

ศิริชัย นามบุรี                                                                         ั
                                                                                  ฟงกชน(Functions)
!                                               66

    cout<<"Result of   10.0+20.25= "<<addition(120.0,20.25)<<endl;
    cout<<"Result of   10.0-20.25= "<<subtract(120.0,20.25)<<endl;
    cout<<"Result of   10.0*20.25= "<<multiply(120.0,20.25)<<endl;
    cout<<"Result of   10.0/20.25= "<<setprecision(3)<<divide(10.0,20.25)<<endl;
    getch();
}
void input() //non-parameter and non-return value function
{
  cout<<"Enter 2 number for calculate : "<<endl<<endl;
  cout<<"Number1 : ";cin>>num1;
  cout<<"Number2 : ";cin>>num2;
}
float addition(float x, float y)
{ float result;
  result=x+y;
result=x-y;
  return (result);
}
float subtract(float x, float y)
{ float result;
  result=x-y;
  return (result);
}
float multiply(float x, float y)
{ float result;
  result=x*y;
  return (result);
}
float divide(float x, float y)
{ float result;
  result=x/y;
  return (result);
}




ศิริชัย นามบุรี                                                                          ั
                                                                                   ฟงกชน(Functions)
!                                                   67

♦! งกชนแบบไมประกาศ prototype
 ฟ ั
         การสรางฟงกชันในโปรแกรมแบบไมประกาศเปน prototype คือ การสรางรายะเอียดของ
ฟงกชันตางๆ ไวกอนฟงกชัน main() การเรียกใชฟงกชันประเภทนี้จะตองเรียกใชตามลําดับของการ
            ั
สรางฟงกชนในโปรแกรม ฟงกชันที่ถูกเรียกใชจะตองสรางอยูกอนฟงกชันที่เรียกใชเสมอ เหมาะสําหรับ
                                    ้
การเขียนโปรแกรมงาย ๆ หรือมีขนาดสัน ๆ ไมสลับซับซอนมากนัก

           •! ตัวอยางโปรแกรม non_prot.cpp แสดงการสรางฟงกชนแบบไมประกาศ prototype ไวกอน
                                                             ั
              ดังรายละเอียดโปรแกรมในหนาตอไป

/*Program : non_prot.cpp
 Process : creat non prototype function */
#include <iostream.h>
#include <conio.h>

// create non-prototype function before function main()
void line1(int amount) //parameter function
{
  int x;
  for(x=1; x<=amount;++x)
   cout<<"_";
  cout<<'\n';
}
void line2() //non-parameter function
{
  cout<< "*********************************\n";
  line1(65);
}
//begin main program
void main()
{
  clrscr();
  cout<< "Display line from line1() function\n";
  line1(40);      //call line1() and constant argument is 40
  getch();
  cout<< "\nDisplay line from line2() function\n";
  line2();       //call line2() and constant argument is 50
  getch();
} //end main program

ศิริชัย นามบุรี                                                                           ั
                                                                                    ฟงกชน(Functions)
!                                                    68

♦! ินไลนฟงกชัน (inline function)
 อ
          โปรแกรมที่เรียกใชฟงกชันจะมีการเรียกใชหนวยความจํานอยกวาโปรแกรมที่ไมเรียกใชฟงกชัน
ทั้งนี้เพราะฟงกชันจะจองและใชพื้นที่หนวยความจําขณะถูกเรียกใชเทานั้น เมื่อฟงกชันทํางานเสร็จจะคืน
                            ั
พื้นที่หนวยความจําใหกบโปรแกรม สวนโปรแกรมที่ไมเรียกใชฟงกชันจะมีการใชหนวยความจําเต็มที่
ตลอดเวลาตามความตองการของโปรแกรมในขณะทํางาน
          โปรแกรมที่เรียกใชฟงกชันมีสวนดีในแงประหยัดการใชหนวยความจํา แตการเรียกใชฟงกชัน
                                   ่
ทําใหโปรแกรมตองใชเวลาเพิม มีผลทําใหการทํางานของโปรแกรมชากวาโปรแกรมที่ไมเรียกใชฟงกชัน
แตเราสามารถกําหนดใหฟงกชันในโปรแกรมถูกเรียกใชโดยจองพื้นที่หนวยความจําตลอดเวลา ไมเสีย
                                          ั
เวลาในการเรียกใช โดยกําหนดใหฟงกชนเปนประเภท อินไลนฟงกชัน (inline function)
          วิธีการสราง อินไลนฟงกชัน (inline function) มีวิธีการดังนี้
          1. สรางอินไลนฟงกชันอยูกอนฟงกชัน main()
                ่         
          2. เพิมคียเ วิรดคําวา inline ที่สวนหัวของฟงกชัน
          หมายเหตุ ขอจํากัดของอินไลนฟงกชัน คือ ฟงกชันตองมีขนาดสั้น ถาอินไลนฟงกชันมีขนาด
ยาวเกินไป compiler ของ C++ จะ compile ใหเปนฟงกชันที่มีการเรียกใชแบบปกติ
          •! ตัวอยางโปรแกรม inline.cpp แสดงการสรางและการเรียกใช อินไลนฟงกชัน ชื่อ square()
                  ่           ํ
               ซึงทําหนาที่คานวณหาคาเลขยกกําลังสอง ดังนี้

/*Program : inline.cpp
 Process : creat and call inline function*/
    #include<iostream.h>
    #include<conio.h>
    inline float square(float number) //declaration inline function
    {
      return(number*number);
    }
    void main() //begin function main()
    { float x;
      clrscr();
      cout<< "Enter number to calculate square : ";
      cin>>x;
      cout<< "Result of square = "<<square(x); //call square() function
      getch();
    }

ศิริชัย นามบุรี                                                                              ั
                                                                                       ฟงกชน(Functions)
!                                                  69

♦! ปแบบการสงอารกวเมนตใหฟงกชน (reference argument)
 รู               ิ          ั
               ั         ่
        ฟงกชนประเภททีสรางแบบมีพารามิเตอร(parameter)      เมื่อถูกเรียกใชจะตองมีการสงอารกิว
                                               ่                          ่ ่ี        ิ
เมนต (argument) ไปใหแกฟงกชันนั้น ๆ โดยทีชนิดของตัวแปรหรือคาคงทีทของอารกวเมนตจะตอง
                                     ั     ํ                                     ่ี ี
เปนชนิดเดียวกับพารามิเตอรของฟงกชนและมีจานวนเทากับพารามิเตอร และกรณีทมพารามิเตอรมาก
                            ิ                                    ่ี
กวา 1 ตัว ลําดับการสงอารกวเมนตตองตรงกับลําดับของพารามิเตอรทกําหนดไว ดังตัวอยาง เชน



           void main()
           { int x = 5, y=2;
              float result;
              result = power(x, y); //เรียกใชฟงกชัน power() ตองสง argument x และ y ไปใหฟงกชัน
           }                       โดยที่ x และ y เปนตัวแปรประเภท int เหมือนกับตัว parameters

           float power(int base, int exp) //ตัวแปร base , exp เปน parameters ของ function
           {                              //รอรับคาจาก argument x และ y ตามลําดับ
             statement1;
             statement2;
             return value;
           }

           ลักษณะของการสงอารกิวเมนตที่เปน ตัวแปร ใหแกฟงกชัน มี 2 ลักษณะ คือ
                                                                               ่
           1. สงเฉพาะคาอารกิวเมนต (passed argument by value) หมายถึง เมือสงคาของตัวแปรทีเ่ ปน
       ิ                                      ั
อาร็กวเมนตไปใหแกพารามิเตอรของฟงกชนแลว เมื่อฟงกชันทํางานเสร็จแลว คาตัวแปรทีเ่ ปนอารกว        ิ
         ั                                              ั           ิ           ่
เมนตยงคงมีคาเดิม การทํางานของฟงกชันไมมีผลทําใหตวแปรอารกวเมนตเปลียนแปลงคา เรียกอารกว         ิ
                  ้
เมนตประเภทนีวา value argument
                                                                            ่
           2. สงและเปลี่ยนคาอารกิวเมนต(passed argument by reference) เมือสงคาของตัวแปรทีเ่ ปน
     ิ                                      ั
อาร็กวเมนตไปใหแกพารามิเตอรของฟงกชนแลว เมื่อฟงกชันทํางานเสร็จแลว คาตัวแปรทีเ่ ปนอารกว      ิ
เมนตมีการเปลี่ยนแปลง                                       ั          ิ           ่
                                การทํางานของฟงกชันทําใหตวแปรอารกวเมนตเปลียนแปลงคาไปจากเดิม
             ิ            ้
เรียกอารกวเมนตชนิดนีวา reference argument




ศิริชัย นามบุรี                                                                                 ั
                                                                                          ฟงกชน(Functions)
!                                                   70

        รูปแบบการกําหนดและการเรียกใชฟงกชันที่มีการสงอารกิวเมนตแบบ value argument และ
                      ั
reference argument มีดงนี้

           #include <header file>
           //declaration prototype function
           float square(float number);
           float area(float& width, float& high);

           void main()
           { float x,y,z;
              statement;
            }
           float square(float number) // value argument function
           {
              statement;
               return value_of_function;
           }
           float area(float& width, float& high) // reference argument function
           {
               statement;
               return value_of_function;
           }

       หมายเหตุ การกําหนดฟงกชนใหเปนประเภท reference argument ใชเครืองหมาย & ตอทาย
                                 ั                                      ่
                                                                               ้
ชนิดขอมูลของพารามิเตอรในการกําหนดสวนหัวของฟงกชัน ในฟงกชันสามารถกําหนดทัง reference
argument และ value argument รวมกันได




ศิริชัย นามบุรี                                                                         ั
                                                                                  ฟงกชน(Functions)
!                                                71

        •! ตัวอยางโปรแกรม argument.cpp แสดงการเปรียบเทียบการเรียกใชฟงกชันแบบ value
                                                                      
             argument และ แบบ reference argument
/*Program : argument.cpp
 Process : show creat and call value and reference function*/

    #include <iostream.h>
    #include <conio.h>
    //declaration prototype function
    float sum(float arg1,float arg2);
    float multiply(float& arg3,float& arg4);
 void main() //begin main program
 {
   float arg1,arg2,arg3,arg4;
   clrscr();
   cout<< "Please enter 4 number for argument : \n";
   cout<< "Argument1 : ";cin>>arg1;
   cout<< "Argument2 : ";cin>>arg2;
   cout<< "Argument3 : ";cin>>arg3;
   cout<< "Argument4 : ";cin>>arg4;
   //display call value argument function
   cout<< "\n\nDisplay call function sum() and send value argument";
   cout<< "\nValue argument before send to function :";
  cout<< "\nArgument 1 = "<<arg1<< " Argument 2 ="<<arg2;
  cout<< "\nResult of sum = "<<sum(arg1,arg2);
  cout<< "\nValue argument after send to function :(not change)";
  cout<< "\nArgument 1 = "<<arg1<< " Argument 2 ="<<arg2;
  // display call reference argument function
  cout<< "\n\nDisplay call function multiply() and send reference argument";
  cout<< "\nValue argument before send to function :";
  cout<< "\nArgument 3 = "<<arg3<< " Argument 4 ="<<arg4;
  cout<< "\nResult of multiply from function= "<<multiply(arg3,arg4);
  cout<< "\nValue argument after send to function :(changed)";
  cout<< "\n\aArgument 3 = "<<arg3<< " Argument 4 ="<<arg4;
  getch();
} //end main program
 float sum(float para1, float para2) //value argument function
 {
   return para1+para2;
 }
float multiply(float& para3, float& para4) //reference argument function

ศิริชัย นามบุรี                                                                      ั
                                                                               ฟงกชน(Functions)
!                                                     72

    {
        para3++; //change para3 and return valut to arg3
        para4++; //change para4 and return valut to arg4
        return para3*para4;
    }


♦! verloaded function
 O
           โอเวอรโหลดฟงกชน(overloaded function) เปนฟงกชันที่สามารถทํางานไดหลาย ๆ ลักษณะ
                                ั
                                    ํ         ้ ่       ั
ขึ้นอยูกับอารกิวเมนตที่ผูใชกาหนดให ดังนันชือฟงกชนประเภทนี้ ขณะเรียกใชจึงสามารถกําหนดอาร
กิวเมนตไดหลายลักษณะ
           วิธีการสราง overloaded function มีวิธีการสรางเหมือนกับฟงกชันปกติ แตมีการสรางชื่อ
                                  ี ่ื
overloaded function ใหมชอเหมือนกัน โดยกําหนดพารามิเตอรแตละฟงกชันใหแตกตางกัน ดังตัว
อยางในโปรแกรม
           •! โปรแกรม over_fun.cpp แสดงการสราง overloaded function ชื่อฟงกชัน line()

/*Program : over_fun.cpp
  Process : creat and call overloaded function line()*/
#include <iostream.h>
#include <conio.h>
//declaration overloaded prototype function
void line();
void line(int x);
void line(char ch,int x);
void line(char ch);
void main() //begin main program
{
  clrscr();
  cout<< "Display 1 line from line() function\n";
  line();                   //call line()
  cout<< "Display 2 line from line() function\n";
  line(30);                 //call line()
  cout<< "Display 3 line from line() function\n";
  line('*',60);             //call line()
cout<< "Display 4 line from line() function\n";
  line('+');                 //call line()
  getch();
} //end main program
void line() //overload function1 line()

ศิริชัย นามบุรี                                                                         ั
                                                                                  ฟงกชน(Functions)
!                                                 73

{
    cout<< "================================\n";
}
void line(int x) //overload function2 line()
{ int y;
  for (y=1;y<=x;++y)
    cout<< "_";
  cout<<'\n';
}
void line(char ch,int x) //overload function3 line()
{ int y;
  for (y=1;y<=x;++y)
    cout<< ch;
  cout<<'\n';
}
void line(char ch) //overload function4 line()
{ int y;
  for (y=1;y<=80;++y)
    cout<< ch;
  cout<<'\n';
}

♦! efault argument
 D
                                                            ่
         การประกาศ prototype function สามารถกําหนดคาเริมตน (default) ใหกับฟงกชันได ในขณะ
                                                                               ํ
เรียกใชฟงกชันทําใหเราสามารถกําหนดอารกิวเมนตไดหลายลักษณะ ถึงแมเราไมกาหนด หรือกําหนด
                                                                ิ          ้
อารกิวเมนตเพียงบางสวน ฟงกชันก็ยังสามารถทํางานได เรียกอารกวเมนตแบบนีวา default argument

           •! ตัวอยางโปรแกรม default.cpp แสดงการสรางฟงกชันแบบกําหนด default argument ไว
              สําหรับการเรียกใชพังกชัน




/*Program : argument.cpp

ศิริชัย นามบุรี                                                                       ั
                                                                                ฟงกชน(Functions)
!                                                  74

 Process : creat and call default argument function line()*/
#include <iostream.h>
#include <conio.h>
//ประกาศ prototype function และกําหนด default argument
void line(char ch= '_',int x=80);
void main() //begin main program
{
  clrscr();
  cout<< "Display line from line() function\n";
  line();         //call line() function
  line('+');      //call line() function
  line('#',50); //call line() function
  line(65);       //call line() will display character of ASCII CODE 65
  getch();
}//end main program
void line(char ch,int x) //function line()
{
  for (int y=1;y<=x;++y)
    cout<< ch;
  cout<<'\n';
}

♦! กษณะการใชตวแปรในฟงกชน
 ลั           ั           ั
        การใชหรือการประกาศตัวแปรในโปรแกรมของ C++ สามารถกําหนดใหตัวแปรมีลักษณะการ
ใชงานได 3 ลักษณะ คือ
        1. automatic variable เปนการประกาศตัวแปร อยูใน { } ของฟงกชันใดฟงกชันหนึ่ง ตัว
             ้                                                        ่
แปรประเภทนีจะนําไปใชไดเฉพาะในฟงกชันนี้เทานั้น จึงเรียกอีกอยางหนึงวา Local variable การ
                                        ้ ่
ทํางานของตัวแปรประเภทนี้ จะจองพืนทีหนวยความจําเมื่อฟงกชันถูกเรียกใชเทานั้น และยกเลิกการใช
                                                               ํ    ่           ั
หนวยความจําเมื่อฟงกชันทํางานเสร็จ ปกติ C++ จะไมกาหนดคาเริมตนใหแกตวแปร automatic
               ้                     ่      ั               ่
variable ดังนันผูใชควรกําหนดคาเริมตนใหกบตัวแปรดวยเพือปองกันความผิดพลาด การกําหนดตัว
                                                    ็
แปร automatic variable จะใชคียเวิรด auto หรือไมกได เชน



                  void main()


ศิริชัย นามบุรี                                                                        ั
                                                                                 ฟงกชน(Functions)
!                                                        75

                         { int x=50;             //declaration x and number are automatic variable in main()
                      auto float number = 0; //used keywoad auto before type and name fo variable
                      statement;
                            …
                  }
                         void repeat() //function repeat()
                         { int y;        //declaration y is automatic variable
                            for(y=1;y<=40;++y) //use y from automatic or local variable
                                cout<<'#';
                            cout<<endl;
                }
                                                         
         2. external variable เปนการประกาศตัวแปร อยูนอก { } ของทุกฟงกชัน ตัวแปรประเภทนี้
                                               ่
จะนําไปใชไดในทุกฟงกชัน จึงเรียกอีกอยางหนึงวา Global variable การทํางานของตัวแปรประเภทนี้
        ้ ่                          ่
จะจองพืนทีหนวยความจําตลอดเวลาทีโปรแกรมทํางาน และยกเลิกการใชหนวยความจําเมือโปรแกรม่
                              ํ         ่        ั         ิ           ู     ้ 
ทํางานเสร็จ ปกติ C++ จะไมกาหนดคาเริมตนใหอตโนมัตแตอาจจะไมถกตอง ดังนันผูใชควรกําหนดคา
   ่
เริมตนใหกบั
              ่
ตัวแปรดวยเพือปองกันความผิดพลาด การกําหนดตัวแปร external variable จะกําหนดหรือประกาศไว
กอนฟงกชัน main()
                  int y=0; //declaration y and x are external variable
                  float x=0;
                         void main() //function main()
                         { int x=50; //declaration x and number are automatic variable in main()
                           statement;
                           …
                  }
        หมายเหตุ ชือตัวแปรประเภท automatic และ external สามารถกําหนดชือซํากันได เนืองจาก
                      ่                                                       ่ ้        ่
ใชหนวยความจําพื้นที่คนละสวนกัน
        3. static variable เปนการประกาศตัวแปร อยูใน { } ของฟงกชันใดฟงกชันหนึ่ง ตัวแปร
                                                                                        ้ ่
ประเภทนี้จะนําไปใชไดเฉพาะในฟงกชันนี้เทานั้น การทํางานของตัวแปรประเภทนี้ จะจองพืนทีหนวย
                        ่
ความจําไวตลอดเวลาทีโปรแกรมทํางาน และยกเลิกการใชหนวยความจําโปรแกรมจบการทํางาน เรียก
           ่
อีกอยางหนึงวา static automatic variable จะใชคียเวิรด static นําหนาในการประกาศตัวแปร เชน



                         float Avg(float value)


ศิริชัย นามบุรี                                                                                     ั
                                                                                              ฟงกชน(Functions)
!                                                     76

                     { static float total; //declaration static variable in function Avg()
                  static int amount;
                        total = total+value; //summation         of total
                        statement;
                      }

        •! ตัวอยางโปรแกรม type_var.cpp แสดงการกําหนดและการใชตัวแปรประเภท automatic
             และ external variable ในโปรแกรม
/*Program : type_var.cpp
 Process : show using automatic and external variable
*/
#include <iostream.h>
#include <conio.h>

void line(); //declaration prototype function
void repeat();
int x; //declaration external or global variable
void main() //begin main program
{ int x;        //declaration automatic or global variable in main()
 auto int y; //declaration automatic or global variable in main()
 clrscr();
 line();
 repeat();
 for(y=1;y<=5;++y) //use y is automatic or local variable
      line();
 for(x=1;x<=5;++x) //use x is automatic or local variable
      repeat();
getch();
} //end main program
void line() //function line()
{ for(x=1;x<=80;x++) //use x from global or external variable
  cout<<'=';
  cout<<endl;
 }

void repeat() //function repeat()
{int y;

ศิริชัย นามบุรี                                                                                    ั
                                                                                             ฟงกชน(Functions)
!                                                 77

    for(y=1;y<=40;++y) //usy y from automatic or local variable
      cout<<'#';
    cout<<endl;
}

♦! emplate Function
 T
          เท็มเพลตฟงกชัน (Template Function) หมายถึง ฟงกชันที่มีคุณสมบัติในการใชอากิวเมนต
(argument) ไดกับขอมูลหลาย ๆ ประเภท เท็มเพลตฟงกชันกําหนดใหพารามิเตอรของฟงกชนสามารถั
รับคาอารกิวเมนตไดหลายประเภท เชน ฟงกชัน sum() กําหนดใหเปนประเภท template function
สามารถรับคาจากตัวแปรประเภท int, float และ double ได คํานวณมาหาผลรวมไดทงอารกวเมนต ้ั   ิ
                                        ่       ั                               ิ
ประเภท int, float และ double ซึงในฟงกชนแบบปกติพารามิเตอรจะรับอารกวเมนตไดเฉพาะขอมูล
                      ํ
ประเภทเดียวกันกับที่กาหนดไวเทานัน   ้
        การกําหนด template function กําหนดไวกอนหนาฟงกชัน main() มีรปแบบดังนี้
                                                                              ู
                 template <class Type>
                 Type Sum(Type first, Type second) //function sum()
                 { statement;
                   statement;
                    return first+second;
                 }
        สวนประกอบใน template function มีดงนี้    ั
                                  ่
        1. template เปนคียเ วิรดเพือกําหนดวา ฟงกชัน sum() เปน template function
                                            ่                        ่ื
        2. <class Type> class เปนคียเ วิรดเพือกําหนดชนิดขอมูล มีชอวา Type ซึ่งสามารถกําหนด
  ่                                         ้ ่
ชือไดตามความตองการของผูใช ตามกฎการตังชือของ C++
        3. Type Sum(Type first, Type second) ชื่อฟงกชัน sum() มีประเภทเปน Type มีพารา
มิเตอร 2 ตัว มีชนิดเปน Type เชนกัน

           •! ตัวอยางโปรแกรม template.cpp แสดงการใชฟงกชันประเภท template function ชื่อ sum()
                         ํ
              ทําหนาที่คานวณหาผลรวมของเลข 2 จํานวน ฟงกชันชื่อ multiply() หาผลคูณเลข 2
              จํานวน ซึ่งเปนตัวเลขประเภท integer, float และ double


/*Program : template.cpp
 Process : show create and call template function */

ศิริชัย นามบุรี                                                                         ั
                                                                                  ฟงกชน(Functions)
!                                         78

  #include <iostream.h>
  #include <conio.h>
  //declaration templat function sum()
  template<class TYPE>
  TYPE sum(TYPE first, TYPE second)
  {
     return first+second;
  }
  //declare template function multiply()
  template<class New_type>
  New_type multiply(New_type number1,New_type number2)
  {
     return number1*number2;
  }
void main() //begin main program
 { int x=50,y=30;
   float a=300.25, b=100.50;
   double c=3.21541005,d=10005.02541152;
   //begin statement
   clrscr();
   cout<< " Sum integer "<< sum(x,y)<<endl;
   cout<< " Sum float "<< sum(a,b)<<endl;
   cout<< " Sum double "<< sum(c,d)<<endl;
   cout<< "\n Multiply integer "<< multiply(x,y)<<endl;
   cout<< " Multiply float "<< multiply(a,b)<<endl;
   cout<< " Multiply double "<< multiply(c,d);
   getch();
 } //end main program




ศิริชัย นามบุรี                                                 ั
                                                          ฟงกชน(Functions)
!                                            79

♦! บบฝกหัดทายบท
 แ

                                                                         ํ
1. ใหเขียนโปรแกรมสรางฟงกชันเสนกรอบสี่เหลี่ยม โดยกําหนดพารามิเตอรกาหนดตําแหนง มุมซาย
   ดานบนและมุมขวาดานลางของกรอบได เชน frame(5,2,50,10) แสดงวากรอบสี่เหลี่ยมจะเริ่มวาด
     ้ ํ
   ตังแตตาแหนง มุมซายบนที่ คอลัมน 5 แถว 2 และมุมขวาลางที่ตําแหนง คอลัมน 50 แถวที่ 10
                5,2



                                                             50,10

                         ่                 ั                       ่
2. ใหเขียนโปรแกรมเพือสรางฟงกชนคํานวณคา factorial(n) เพือคํานวณหาคาแฟกทอเรียลของ
   จํานวน n
3. ใหเขียนโปรแกรมเพื่อสรางฟงกชันแบบพารามิเตอรและมีการ return value ในการคํานวณเลข
   ยกกําลังโดยการสง argument เปนเลขจํานวนฐานและเลขกําลังไปใหแกฟงกชัน เชน power(2,4)
   คือการคํานวณเลขจํานวน 2 ยกกําลัง 4
                           ่                 ั
4. ใหเขียนโปรแกรมเพือสรางฟงกชนประเภทมีพารามิเตอรและมีการ return value ในการคํานวณหา
         ้ ่
    คาพืนทีของรูปเรขาคณิตตอไปนี้ วงกลม, สามเหลี่ยม และ สี่เหลี่ยม
                             ่                                                ่
5. จงเขียนโปรแกรมเพือคํานวณการตัดเกรด โดยการเขียนแยกเปนฟงกชัน มีเงือนไขการตัดเกรด ดังนี้
         คะแนน 0-49 เกรด F                      คะแนน 50-59 เกรด D
         คะแนน 60-69 เกรด C                     คะแนน 70-79 เกรด B
         คะแนน 80-100 เกรด A
    ในโปรแกรมใหสรางฟงกชนตอไปนี้ั
    void input()                        ทําหนาที่รับคะแนนระหวางภาคและปลายภาคเรียน
                                                   ่
    int summation(int x, int y) ทําหนาทีในการรวมคะแนน
    char calculate(int total)                    ่
                                        ทําหนาทีในการตัดเกรด
    void display()                      ทําหนาที่ในการแสดงผลขอมูลของโปรแกรมทั้งหมด
                                      ั                                           ่
6. ใหเขียนโปรแกรมสรางฟงกชนประเภทมีพารามิเตอรและมีการ return value เพือคํานวณหาผลรวม
    ของเลขอนุกรม 2 ฟงกชัน โดยมีชื่อฟงกชัน sum_even() และ sum_odd มีการทํางาน ดังตัวอยาง
    sum_odd(1,10)              คือหาผลรวมของ 1+3+5+7+9
    sum_odd(9,20)              คือหาผลรวมของ 9+11+13+15+17+19



ศิริชัย นามบุรี                                                                      ั
                                                                               ฟงกชน(Functions)
!                                              80

     sum_even(1,10)     คือหาผลรวมของ 2+4+6+8
     sum_even(9,20)     คือหาผลรวมของ 10+12+14+16+18+20
7. Write the function digitsum(n) ,which computes and returns the sum of the decimal digits
   of the integer parameter n.
8. Write the function sort4, which has four parameters. If the integer variables a,b,c and d are
   available and have been assigned values, we want to write
       sort4(&a, &b,&c,&d);
   to sort four variables, so that, after that call, we have a<=b<=c<=d




ศิริชัย นามบุรี                                                                          ั
                                                                                   ฟงกชน(Functions)

				
DOCUMENT INFO
Shared By:
Categories:
Tags: lesson5
Stats:
views:6
posted:6/23/2011
language:Thai
pages:23