FUNCTION IN C++(Функции в языке С++)

 Function in C++(Функции в языке С++)

Function ဆိုသည္မွာ logical သေဘာတရားအရသာတည္ရွိၿပီး ပရိုဂမ္၏ အၿခားအစိတ္အပိုင္းမ်ားမွ ေခၚယူအသံုးၿပဳနိဳင္ေအာင္ ဒီဇိုင္းေရးဆြဲထားေသာ ပရိုဂမ္အပိုင္းအစ ပံုစံၿဖစ္သည္။function သည္ ၾကီးမားေသာ တြက္ခ်က္မွဳ႕ဆိုင္ရာ ပုစၦာမ်ားအား မ်ားစြာေသာ အစိတ္အပိုင္းငယ္ေလးမ်ားအၿဖစ္သို႕ ထပ္မံခြဲထုတ္နိဳင္သည္။ ထို႕အတူ အဆင္သင့္ေရးသားထာေသာ subprogram မ်ားကိုလည္း အသံုးနိဳင္ေစရန္ အတြက္ ခြင့္ၿပဳေပးသည္။

အကယ္၍ function အားမွန္ကန္စြာနွင့္ နည္းစနစ္က်စြာ ေရးသားၿပီးလွ်င္ တစ္ၿခား ပရိုဂမ္အစိတ္အပိုင္းသည္ ၎အားမလိုအပ္ပါက လည္း ၎၏ body အတြင္းတြင္ပင္ ေဖ်ာက္ဖ်က္ထားနိဳင္သည္။ထိုသို႕ ၿပဳလုပ္နိဳင္ၿခင္းသည္ ေယဘူယ်အားၿဖင့္ ပရိုဂမ္အားရွင္းရွင္းလင္းလင္း ၿဖစ္ေစသည္။ထို႕အတူ ၎အား debug ၿပဳလုပ္ရာနွင့္ change ၿပဳလုပ္ရာတြင္လည္း ပိုမိုလြယ္ကူေခ်ာေမြ႕ေစသည္။function မ်ားသည္ ပရိုဂမ္မ်ားအားလံုးအတြက္ global မ်ားၿဖစ္ၾကသည္။

Declaration and definition of function(Объявление и определение функций) 

Function မ်ားအားအသံုးၿပဳတက္ေစရန္အတြက္ declaration နွင့္ definition အားဦးစြာ နားလည္ရန္ လိုအပ္ေပသည္။
function တစ္ခုအား declare ၿပဳလုပ္ရန္အတြက္ prototype နွင့္ ၎၏ parameter မ်ားတြင္ ပါ၀င္ေသာ data မ်ားအား မည္ကဲ့သို႕ေရးသားရမည္ကို သိရွိေလ့လာရမည္ၿဖစ္သည္။

type function_name ( data.par1,data.par2,…..)
ထိုသို႕ေ၇းသားရာတြင္ data.part ဟူေသာ parameter ေနရာတြင္ ေအာက္ေဖာ္ၿပပါ format မ်ားအနက္မွ တစ္ခုၿဖစ္ရမည္။
data_type (သို႕) data_type parameter_name,
ဆိုလိုသည္မွာ function ၏ parameter မ်ားအား မိမိနွစ္သက္ရာ နာမည္ေပးၿပီး ေၾကၿငာနိဳင္သလို အမည္နာမ မေပးၿခင္းၿဖင့္လည္းေၾကၿငာနိဳင္သည္။
void My_Func (int Par1, float Par2, double Par3);

void My_Func (int, float, double);

အထက္ေဖာ္ၿပပါ ေရးသားသည့္နည္းစနစ္နွစ္ခုစလံုးသည္ သေဘာတရားအရအတူတူပင္ၿဖစ္သည္။ အဘယ္ေၾကာင့္ဆိုေသာ္ complier သည္ parameter ၏ အမည္မ်ားအား လစ္လွူရွဳ႕၍ ၎တို႕၏ data type မ်ားသာ အဓိကထား၍ အလုပ္လုပ္ေသာေၾကာင့္ၿဖစ္သည္။ထိုသို႕ၿဖစ္ရၿခင္းသည္ function အား prototype မ်ားနွင့္ေရးသားၿခင္းသည္ function မ်ား access ၿပဳလုပ္ရာတြင္ သင့္ေတာ္ေသာ ပမာဏနွင့္ parameter type မ်ားနွင့္ မွန္ကန္စြာ ၿပဳလုပ္ေစရန္အတြက္ complier မွ execute ၿပဳလုပ္ေပးနိဳင္ေသာေၾကာင့္ၿဖစ္သည္။ထို႕အတူ လိုအပ္ေသာ ၿပဳၿပင္ေၿပာင္းလဲၿခင္းမ်ားထပ္မံ ၿဖည့္စြပ္ၿခင္းမ်ားလည္းၿပဳလုပ္နိဳင္သည္။function prototype မ်ားသည္ အၿမဲတမ္း semicolon ၿဖင့္ အဆံုးသတ္ေလ့ရွိသည္။

function ၏ သေကၤတလကၡဏာမ်ားၿဖစ္ေသာ ကိန္းဂဏာန္းမ်ားနွင့္ argument types မ်ားပါ၀င္ေသာ prtototype မ်ားၿဖင့္ ဖြဲ႕စည္းထားလွ်င္ function ၿဖစ္သည္ဟုေၿပာဆိုနိဳင္သည္။

အကယ္၍ function အား declaration ၿပဳလုပ္ၿပီးလွ်င္ program ၏ မည္သည့္ေနရာတြင္မဆို definition ၿပဳလုပ္နိဳင္သည္။သို႕ေသာ္ main() function အပါအ၀င္ မည္သည့္ function အတြင္းတြင္မဆို definition ၿပဳလုပ္၍ မရေပ။ 

function အား definition သတ္မွတ္ရာတြင္ ပထမဦးစြာ headline တြင္ေၾကၿငာခဲ့သည့္ protocol မ်ားနွင့္ title အား ၿပန္လည္ေရးသားရမည္ၿဖစ္ၿပီး ထိုသို႕ၿပန္လည္ေရးသားရာတြင္ semicolom ၿပန္လည္ပါ၀င္ရန္မလိုအပ္ေပ။ ထို႕ေနာက္တြင္မွသာ bracket ထဲတြင္ function ၏ body အားေရးသားရမည္ၿဖစ္သည္။

function ၏ format သည္ေအာက္ပါအတိုင္းၿဖစ္သည္။

data_type function_name(data_type parameter_name,……….,data_type parameter_name)

{

          //function body

}

Example.

# include <iostream>

using namespace std;

# include <iomanip.h>

void CntUp (void); / / declaration

void CntDown (void); / / function prototypes.

 int main ()

{CntUp (); / / using functions

 CntDown (); / / in the program (ie, their challenge)

 return 0;

}

void CntUp (void) / / definition of function_CntUp

{        int i;

         cout << "count from 1 to 10" << endl;

         for (i = 1; i<= 10; i++) cout << setw (4) << i;

         cout << endl;

}

void CntDown (void) / / definition of function_CntDo wn

{        int i;

         cout << "count from 10 to 1" << endl;

         for (i = 10; i> = 1; i -) cout << setw (4) << i;

        cout << endl;

}

The concept of function parameters (Понятие о параметрах функций)

formal and actual parameters(формальный и  фактический параметр )

Declaration နွင့္ definitation ၿပဳလုပ္ထားေသာ function မ်ား၏ prototype မ်ားအား formal parameter (формальный параметр) ဟုေခၚဆိုၿပီး function အား call ၿပဳလုပ္ရန္အတြက္ formal ေနရာတြင္ အစားထိုး ထည့္သြင္းေသာ parameter မ်ားအား actual parameter ( фактический параметр) ဟုေခၚဆိုသည္။ အကယ္၍ function အားအလုပ္လုပ္ရာတြင္ parameter အားတစ္ခုထက္ပိုမို၍ အသံုးၿပဳရန္ လိုအပ္ပါက bracket ထဲတြင္ parameter list ထားရွိရမည္ၿဖစ္ၿပီး တစ္ခုနွင့္တစ္ခုအား comma ၿဖင့္ပိုင္းၿခားရမည္ ၿဖစ္သည္။

Example 11.2. Passing parameters to a function and getting a return value.

# include <iostream>

using namespace std;

# include <iomanip.h>

int max (int a, int b);   / / Function prototype of the search for a maximum of two parameters

 void main ()

{        int m, k, l;

cout << "m =";

cin >> m;

cout << "k =";

cin >> k;

l = max (m, k);

cout << "max =" << l << endl;

}

int max (int a, int b)

{        if (a> b) return a;

else return b;

}

သည္တြင္ a နွင့္ b သည္ formal parameter  (формальный параметр)  မ်ားၿဖစ္ၿပီး m နွင့္ k သည္ actual parameter ( фактический параметр) မ်ားၿဖစ္ၾကသည္။

Local and global parameters(Локальные и глобальные переменные  ) 

Main function အပါအ၀င္ မည္သည့္ function အတြင္းတြင္မဆို ေၾကၿငာထားေသာ variable မ်ားအား local variable ဟုေခၚဆိုၿပီး function သည္ active ၿဖစ္ေနသည့္အခ်ိန္တြင္သာ ကြန္ပ်ဴတာ memory ေပၚတြင္ေနရာယူမည္ၿဖစ္သည္။main function အပါအ၀င္ မည္သည့္ function မ်ား၏ ၿပင္ပတြင္ ေၾကၿငာထားေသာ variable မ်ားအား global parameter မ်ားဟုေခၚဆိုသည္။local variable မ်ားအား တစ္နည္းအားၿဖင့္ automatic variable မ်ားဟုေခၚဆိုသည္ အဘယ္ေၾကာင့္ဆိုေသာ္ ၎တို႕အား အလိုအေလ်ာက္ program မွ ဖန္တီးၿပီး ဖ်က္စီးလိုက္ေသာေၾကာင့္ၿဖစ္သည္။Stack ဆိုသည္မွာ data element မ်ားအား ေပါင္းထည့္ၿခင္း ဖ်က္စီးခ်င္း မ်ားၿပဳလုပ္နိဳင္ရန္ ဖြဲ႕စည္းတည္ေဆာက္ထားေသာ memory area တစ္ခုၿဖစ္သည္။သို႕ေသာ္ ေနာက္ဆံုးၿဖည့္စြက္လိုက္ေသာ element သာလွ်င္ access ၿပဳလုပ္နိဳင္မည္ၿဖစ္သည္။

  

Function ၏ local variable မ်ားအား ထို stack ေပၚတြင္ stored ၿပဳလုပ္ထားၿခင္းၿဖစ္သည္။function ၏ parameter မ်ားသည္လည္း stack ေပၚတြင္သာ store ၿပဳလုပ္ထားသည္ၿဖစ္သည္။ထို႕ေၾကာင့္ ၎တို႕အား local variable ဟုသတ္မွတ္နိဳင္သည္။

Function မ်ားအား call ေခၚၿပီး ၎တို႕အား return ၿပန္ေသာအခါ stack သည္ dynamically အရသာ လုပ္ေဆာင္မည္ၿဖစ္သည္။

Function အားစတင္အလုပ္လုပ္ေသာအခါ ၎၏ local variable မ်ားအား memory ၏ stack ေနရာတြင္ store ၿပဳလုပ္မည္ၿဖစ္သည္။ထို stack-memory သည္ function active ၿဖစ္ေနေသာအခ်ိန္တြင္သာ တည္ရွိေနမည္ ၿဖစ္သည္။ function မွ return ၿပန္ၿပီးေသာအခါ stack memory သည္ တည္ရွိေတာ့္မည္မဟုတ္ပဲ ၎ေပၚတြင္ store လုပ္ထားေသာ variable အားလံုးတို႕သည္လည္း ေပ်ာက္ကြယ္သြားမည္ၿဖစ္သည္။

Strings,arrays and structure as parameter of function(Строки, массивы и структуры в качестве параметров функций)

String,arrays ႏွင့္ structure တို႕အား function ၏ parameter အေနၿဖင့္ passing ၿပဳလုပ္၍ အသံုးၿပဳနိဳင္သည္။

ကၽြနဳပ္တို႕သည္ string အား function ၏ parameter အၿဖစ္ passing ၿပဳလုပ္နိဳင္ၿပီး function သည္ string အား program ထဲတြင္ return ၿပန္ၿခင္းၿပဳလုပ္နိဳင္သည္။

void Print_String(char string[])

{     cout << string;

}

void main()

{ . . .

    char MyStr[] = “C++ - язык для профессионалов”;

   . . .

    Print_String (MyStr);

. . .

}

Function တြင္ string အားကိုယ္တိုင္ pass ၿပဳလုပ္ၿခင္းမဟုတ္ေပ။ String ၏ အမည္နွင့္သက္ဆိုင္ေသာ ပထမ element ၏ address ကိုသာ passing ၿပဳလုပ္ၿခင္းၿဖစ္သည္။တစ္နည္းအားၿဖင့္ဆိုရေသာ္ string ၏ symbol သည္ function ၏ argument ၿဖစ္ၿပီး(အထက္ပါ ပုစၦာထဲတြင္ MyStr အတြက္သည္ Print_String function ၿဖစ္သည္) stack ေပၚမွာေန၍ passing ၿပဳလုပ္ၿခင္းမဟုတ္ေပ။

const int MAXLEN = 128;

void A_Func(char s[],int len);         // declaration function prototype, processing length 0f //string (len)

. . .

char author[MAXLEN] = “Tom Swan“;

A_Func(author, MAXLEN);

……………………

A_Func သည္ string နွင့္ process ၿပဳလုပ္ရန္ နွစ္သက္ရာ function ၿဖစ္ၿပီး string သည္ character arrays element မ်ားအေနၿဖင့္သာ သတ္မွတ္လိမ့္မည္ ၿဖစ္သည္။အကယ္၍ function တြင္ character array တစ္ခုအား passing ၿပဳလုပ္ေတာ့္မည္ဆိုလွ်င္ ေအာက္တြင္ေၾကၿငာထားေသာ အရာအားသတိၿပဳသင့္သည္။

const int MAXLEN=128;

character ပမာဏ (MAXLEN-1) သာ memory တြင္အသံုးၿပဳနိဳင္မည္ၿဖစ္ၿပီး 0 bit ၿဖင့္အဆံုးသတ္မည္ၿဖစ္သည္။

C++ language တြင္ နွစ္သက္ရာ array ၿဖင့္ function အား passing ၿပဳလုပ္နိဳင္သည္။

Example. Suppose you want to find the sum of element.We decare:

Const int M=100;

Int data[M];

………..

ယခု array argument ပါ၀င္ေသာ function တစ္ခု ေၾကၿငာမည္ၿဖစ္သည္။

int Summa(int mas[M]);

သို႕ေသာ္ ေအာက္ပါအတိုင္းေၾကၿငာလွ်င္ process ၿပဳလုပ္ရာတြင္ ပိုမိုေကာင္းမြန္သည္။

int Summa(int ma[],int n);

……...

ထို႕ေနာက္တြင္ function အား call ၿပဳလုပ္ရန္

cout<<”Summa=”<<Summa(data,M)<<endl;

function သည္ ေအာက္ေဖာ္ၿပပါ နည္းလမ္းအတိုင္း မိမိ၏ ေပါင္းလဒ္အား ရွာေဖြနိဳင္သည္။

int Summa(int mas[],int n)

{        int sum=0;

          for(int 1=0;i<n;i++)

                   sum+=mas[i];

                   return sum;

}

အၿခားနည္းလမ္းၿဖင့္လည္း function ၏ ေပါင္းလဒ္အားရွာေဖြနိဳင္သည္။

int Summa(int mas[],int n)

{        int sum=0;

          While(n>0)

          sum+=mas[--n];

          return sum;

}

numerical နွင့္ character array မ်ားထက္ပိုမို၍ function တြင္ multidimensional array မ်ားလည္း passing ၿပဳလုပ္နိဳင္သည္။အကယ္၍ function တြင္ multidimensional array အား passing ၿပဳလုပ္မည္ဆိုလွ်င္ complier သည္ memory ၏ address အား pass ၿပဳလုပ္ရန္အတြက္ minimum information အား set ၿပဳလုပ္ရမည္ ၿဖစ္သည္။

function အား ေအာက္ပါအတို္င္းေၾကၿငာနိဳင္သည္။

void SomeFunc(int arr[rows][cols]);

(သို႕)

void SomeFunc(int arr[][cols]);

ဒုတိယ နည္းသည္ ပိုမိုေကာင္းမြန္သည္။

သို႕ေသာ္ ေအာက္ေဖာ္ၿပပါနည္းအတိုင္းေၾကၿငာလွ်င္ complie ၿပဳလုပ္လိမ့္မည္မဟုတ္ေပ။

void SomeFunc(int arr[rows][]);

void SomeFunc(int arr[][]);

Example.The integer 4*5 materix to calculate the sum of elements smaller than input number from the keyboard.(4*5 matrix တစ္ခုတြင္ ကီးဘုတ္မွရိုက္ထည့္လိုက္ေသာ ကိန္းထက္ငယ္ေသာ ကိန္းမ်ား၏ ေပါင္းလဒ္ကိုရွာေဖြရန္)

#include <iostream>

using namespace std;

#include <iomanip.h>

#include <conio.h>

#include <stdlib.h>

const int row = 4;

const int col = 5;

//declare prototype functions

void form (int arr[][col], int r, int c);

void print_arr (int arr[][col], int r, int c);

int sum_less (int arr[][col], int r, int c, int dig);

int main()

{ int matr[row][col];

   int a, summa;

   clrscr();

   randomize();

   form (matr, row, col);

   print_arr (matr, row, col);

   cout << "Введите число ";

   cin >> a;

   summa = sum_less (matr,row,col,a);

   cout << "Summa = " <<  summa;

   return 0;

}

void form (int arr[][col], int r, int c)                    // forming matrix

{for (int i = 0; i < r; i++)

      for (int j = 0; j < c; j++)

          arr[i][j] = random(100) - 50;

}

void print_arr (int arr[][col], int r, int c)                        // output matrix on screen

       {for (int i = 0; i < r; i++)

           {for (int j = 0; j <c; j++)

               cout << setw(4) << arr[i][j];

              cout << endl;

    }

}

int sum_less (int arr[][col], int r, int c, int dig)                // computing sum

{ int  s_l = 0;

  for (int i = 0; i < r; i++)

     for (int j = 0; j <c; j++)

        if (arr[i][j] < dig) s_l += arr[i][j];

  return s_l;  

}

Structure မ်ားအား function ၏ parameter အၿဖစ္ passing ၿပဳလုပ္နိဳင္ၿပီး ရလဒ္အား return ၿပန္ၿခင္း ၿပဳလုပ္နိဳင္သည္။

Example.Declare the structure,which determines the circle by specifying the coordinates of center and radius.

typedef struсt circle { int coord_x;

                               int coord_y;

                               int radius;

                             } Circle;

Initialize ၿပဳလုပ္ထားေသာ Circle structure အား return ၿပန္ထားေသာ ေအာက္ေဖာ္ၿပပါ function အတိုင္း ေရးသားနိဳင္သည္။

Circle C;

C=Def_Circle(25,43,15);

ထိုအခ်ိန္တြင္ Def_Circle() သည္ေအာက္ပါအတိုင္း ၿဖစ္သြားလိမ့္မည္ၿဖစ္သည္။

Circle Def_Circle(int x, int y, int r)

{

         Circle rtemp;

         rtemp.coord_x=x;

         rtemp.coord_y=y;

         rtemp.radius=r;

         return rtemp;

 }

rtemp variable သည္ function ၏ local ၿဖစ္ၿပီး scope ၏ အၿပင္တြင္ မတည္ရွိေသာ္လည္း function သည္ rtemp ၏ value အား result အၿဖစ္ return ၿပန္နိဳင္သည္။return operator သည္ rtemp variable အား stack memory ေပၚတြင္ ယာယီ store ၿပဳလုပ္လိုက္ေသာ အခါ ထိုေနရာတြင္ရွိေသာ variable သည္ function ၏ result နွင့္ ထပ္တူညီသြားမည္ၿဖစ္သည္။

Recursion(Рекурсия)

Recurtion ၏ အဓိပါယ္မွာ return ပင္ၿဖစ္သည္။recursive ဆိုသည္မွာ မိမိကုိယ္တိုင္အား return ၿပန္ေသာ function ပင္ၿဖစ္သည္။

Example.Recursive computation of factor .

n!=n*(n-1)*(n-2)*……..*2*1, and 0!=1, 1!=1 – to definite factor.

မည္သည့္ recursive function မဆို recursion အားအသံုးမၿပဳဘဲနွင့္လည္း တြက္ခ်က္နိဳင္သည္။

Fact=1;

for(cnt=n;cnt>=1;cnt--)

fact=fact*cnt;          //or fact*=cnt;

recursive ေၿဖရွင္းသည္ဆိုရာတြင္ ဖန္ရွင္မွ ထိုဖန္ရွင္မွေန၍ တြက္ထုတ္လိုက္ေသာ factorial မ်ားအား ထပ္ခါထပ္ခါ call ေခၚၿခင္းပင္ၿဖစ္သည္။

5!=5*4!

4!=4*3!

3!=3*2!

2!=2*1!

1!=1

1! သည္တြက္ခ်က္ၿခင္းၿဖင့္ရရွိလာေသာ basic task ၿဖစ္သည္။ထို႕အတူဆက္လက္၍ေအာက္ပါအတိုင္း recursion sign မ်ားအားဆက္လက္လုပ္ေဆာင္နိဳင္သည္။

1, = 1 - return 1;

2, = 2 * 1, = 2 * 1 = 2 - return 2;

3, = 3 * 2, = 3 * 2 = 6 - return 6;

4, = 4 * 3, = 4 * 6 = 24 - return 24;

5, = 5 * 4, = 5 * 24 = 120 - return 120.

/ / A recursive function of factorial:

    . . .

unsigned long fact (unsigned long);

int main ()

{        cout << "5! =" << Fact (5);

return 0;

}

/ / Recursive description of the factorial function:

   unsigned long fact (unsigned long i_dat)

{        if (i_dat <= 1) return 1;

else return i_dat * fact (i_dat-1)

}

Example . Recursive computation of the power func tion to.

// A sign of terminating the recursion

. . .

long power (int number, int x);

int main ()

{        cout << "4 to 5 - th level = "<< power (5,4);

          return 0;}

/ / Recursive description of the power function:

    long power (int number, int x)

   {     if (number = 0) return 1;

else return x * power (number-1, x);

    }

အကယ္၍ recursion function အား local variable တစ္ခုခုၿဖင့္ေၾကၿငာခဲ့ပါက ထို variable မ်ားအား recursion ၏ အဆင့္ဆင့္တိုင္းတြင္ created ၿပဳလုပ္လိမ့္မည္ၿဖစ္သည္။

ပံုမွန္အားၿဖင့္ recursive solution မ်ားအား non-recursive ထက္ပိုမို debug ၿပဳလုပ္ရာတြင္ လြယ္ကူေစေသာ အခါမ်ိဳးတြင္ အသံုးၿပဳေလ့ရွိသည္။

http://www.cplusplus.com/doc/tutorial/functions2/

Inline function(Встраиваемые функции)

Function မ်ားအား call ေခၚရာတြင္ ဖန္ရွင္ဆီသို႕ return ၿပန္မည့္ တန္ဖိုးသည္ stack ေပၚမွေန၍ parametrer မ်ားအား transfer ၿပဳလုပ္ရသည့္ လုပ္ေဆာင္ခ်က္သည္ မၿဖစ္မေနၿပဳလုပ္သြားသည္ၿဖစ္သည္။ ထိုသို႕ၿပဳလုပ္ၿခင္းသည္ ပရိုဂမ္မ်ား၏ ၿမန္ဆန္စြာ လုပ္ေဆာင္ခ်က္မ်ားအား က်ဆင္းေစတက္သည္ၿဖစ္သည္။

သို႕ေသာ္ C++ တြင္ ထိုသုိ႕ transfer ၿပဳလုပ္စရာမလိုပဲ call ေခၚသည့္ေနရာသို႕ တိုက္ရိုက္ေရာက္ရွိရန္ program ထဲတြင္ built-in ဖန္ရွင္အား အသံုးၿပဳနိဳင္ရန္ တည္ေဆာက္ေပးထားသည္။

Inline function အား အသံုးၿပဳၿခင္းသည္ call နွင့္ return ၿပန္ေသာ ၿပဳလုပ္မွဳ႕ဆိုင္ရာ အစိတ္အပိုင္းနွင့္ ဆက္စပ္မွဳ႕မရွိေပ။ထို႕ေၾကာင့္ ၎တို႕သည္ ပံုမွန္အားၿဖင့္ ၿမန္ဆန္စြာအလုပ္လုပ္ေဆာင္မည္ၿဖစ္သည္။သို႕ေသာ္ ၎တို႕သည္ program မ်ား၏ code မ်ားအား သိသာစြာ ပိုမိုမ်ားၿပားလာေစသည္။

Example. Built-in function that determines the parity of the passed args from it argument.

# include <iostream>

using namespace std;

# include <conio.h>

inline int even (int x)

{        return! (x% 2);         }

int main ()

{        int dig;

         cout << "Enter number";

         cin >> dig;

         if (even (dig)) cout << dig << "- even" << endl;

             else cout << dig << "- an odd" << endl;

        return 0;

}

Inline function သည္ complier အတြက္ command တစ္ခုမဟုတ္ေပ request တစ္ခုသာၿဖစ္သည္။ထို႕ေၾကာင့္ အကယ္၍ complier သည္ function အားအေၾကာင္းတစ္ခုခုေၾကာင့္ built  မၿပဳလုပ္နိဳင္ပါက ပံုမွန္အားၿဖင့္သာ complie ၿပဳလုပ္သြားမည္ၿဖစ္ၿပီး မည္သည့္ report မွ screen ေပၚတြင္ ထုတ္ေဖာ္သြားမည္မဟုတ္ေပ။

ေအာက္ေဖာ္ၿပပါ အခ်က္မ်ားသည္ complier မ်ားသည္ ဖန္ရွင္အား inline ၿပဳလုပ္နိဳင္မည္မဟုတ္ေပ။

Function တြင္ Loop ပါေသာအခါ

Function တြင္ switch (သို႕) goto ပါ၀င္ေသာအခါ

Function တြင္ recursive ပါ၀င္ေသာအခါ

အမွန္တြင္ program ၏လုပ္ေဆာင္ခ်က္မ်ားသည္ call function ထက္ပိုမို၍  ဆိုးရြားစြာလုပ္ေဆာင္နိဳင္မည္ဟု ယူဆပါက complier သည္ inline declaration အား skip ၿပဳလုပ္နိဳင္သည္။

Function overloading(Перегрузка функций)

C++ program မ်ားတြင္ တူညီေသာ အမည္တစ္ခုတည္းၿဖင့္ အမ်ိဳးမ်ိဳးေသာ function မ်ားေရးသားနိဳင္သည္။သို႕ေသာ္ တူညီေသာ အမည္မ်ားၿဖင့္ေရးသားထားေသာ function မ်ားသည္ ကိန္းအေရတြက္မ်ားနွင့္ ၎တို႕၏ argument type မ်ားၿခားနားရမည္ၿဖစ္သည္။ထိုသို႕ေသာ function မ်ားအား overloaded function မ်ားဟုေခၚဆိုၾကသည္။

Function အား overload ၿပဳလုပ္ရန္အတြက္ ၎အတြက္လိုအပ္ေသာ အခ်က္အလက္မ်ားအား တည္ရွိေစ၇န္ မၿဖစ္မေနၿပဳလုပ္ရမည္ၿဖစ္သည္။complier သည္ argument အားၿဖင့္ သင့္ေတာ္မွန္ကန္ေသာ version အား အလိုအေလွ်ာက္ ေရြးခ်ယ္ၿပဳလုပ္သြားမည္ၿဖစ္သည္။overloading တြင္ return type သည္ အဓိကက်ေသာ အစိတ္အပိုင္းတစ္ခုမဟုတ္ေပ။

Overloaded function မ်ားသည္ program မ်ားအား နာမည္တူ၍ အဓိပါယ္ခ်င္းနီးစပ္ေသာ လုပ္ေဆာင္ခ်က္မ်ားအားလည္း operate ၿပဳလုပ္ရန္ခြင့္ၿပဳေပးသည္။(သို႕ေသာ္ ၎တို႕အတြက္ ကြဲၿပားၿခားနားေသာ algorithmic မ်ားရွိမည္ၿဖစ္သည္။)

Example. An overloaded function is the summation of two integers, the three integers, two reals.(၎တို႕၏ လုပ္ေဆာင္ခ်က္မ်ား(operation)သည္ ကိန္းမ်ားအား ေပါင္းၿခင္းပင္ၿဖစ္သည္.function name သည္ နာမည္တစ္ခုထဲၿဖစ္ၿပီး ၎တို႕၏ operate မ်ားသည္အတူတူပင္ၿဖစ္သည္)

# include <iostream>

using namespace std;

int sum (int a, int b) {return a + b;}

int sum (int a, int b, int c) {return a + b + c;}

float sum (float a, float b) {return a + b;}

int main ()

{int m, k, l;

float p, q;

cout << "m =";

cin >> m;

cout << "k =";

cin >> k;

cout << "l =";

cin >> l;

cout << "p =";

cin >> p;

cout << "q =";

cin >> q;

cout << "m + k =" << sum (m, k) << endl;

cout << "k + l =" << sum (k, l) << endl;

cout << "m + k + l =" << sum (m, k, l) << endl;

cout << "p + q =" << sum (p, q) << endl;

return 0;

}

ပရိုဂမ္တစ္ခုတည္းတြင္ တူညီေသာ အမည္တစ္ခုတည္းနွင့္ ဖန္ရွင္အမ်ိဳးမ်ိဳးအားထား၇ွိ အသံုးၿပဳ နိဳင္ၿခင္းမွာ polymorphism(полиморфизма) ၏ ၀ိေသသနတစ္ရပ္ပင္ၿဖစ္သည္။ လိုအပ္ေသာ အပိုင္းအား ေရြးခ်ယ္ရာတြင္ ပရိုဂမ္အား compile ၿပဳလုပ္ေသာ အဆင့္တြင္ၿဖစ္ေနေသာေၾကာင့္ ၎အား static polymorphism ဟုေခၚသည္။ function overloading ၿပဳလုပ္ရာတြင္ ခက္ခဲေစတက္ေသာ condition(3)ခုရွိသည္။ 

1.overload ၿပဳလုပ္မည့္ function မ်ားတြင္ return type မ်ားသာ ကြဲၿပားၿပီး အၿခားအားလံုးတူညီေနပါက ၎ functions မ်ားသည္ overloaded မၿပဳလုပ္နိဳင္ေပ။

int OverloadFn(char *str); 

char OverloadFn(char *str);

2. overload ၿပဳလုပ္မည့္ function မ်ား၏ argument မ်ားတြင္ reference အသံုးၿပဳမွဳ႕သာ ကြဲၿပားၿခားနားေနပါက ၎ functions မ်ားသည္ overloaded မၿပဳလုပ္နိဳင္ေပ။

int OverloadFn (int param);
int OverloadFn (int & param);

3. overload ၿပဳလုပ္မည့္ function မ်ား၏ argument မ်ားတြင္ modifier မ်ားၿဖစ္ေသာ const နွင့္ volatile အသံုးၿပဳမွဳ႕သာ ကြဲၿပားၿခားနားေနပါက ၎ functions မ်ားသည္ overloaded မၿပဳလုပ္နိဳင္ေပ။

int OverloadFn (int param);

int OverloadFn (const int param);

int OverloadFn (volatile int param);

တူညီေသာ Identifiers မ်ားအား ကြဲၿပားၿခားနားေသာ algorithmically နည္းမ်ားၿဖင့္ အနီးကပ္ဆံုးတူညီေသာ တန္ဖိုးမ်ားရရွိေအာင္ ၿပဳလုပ္နိဳင္ေသာ လုပ္ေဆာင္ခ်က္အား polymorphism ဟုေခၚသည္။

Using default arguments

Default argument အားအသံုးၿပဳၿခင္းသည္ function overloading တြင္အရိုးရွင္းဆံုးပံုစံတစ္ခုၿဖစ္သည္။ function ၏ တစ္ခု argument တစ္ခု(သို႕) တစ္ခုထက္ပိုမို၍ default argument အားအသံုးၿပဳ၍ default ၿပဳလုပ္ထားနိဳင္သည္။function argument မ်ားအား default argument ၿပဳလုပ္ရန္အတြက္ function header တြင္ argument နွင့္ တူညီနွင့္တန္းဖိုးၾကားတြင္ equality sign (=) ထားရွိေပးရမည္ၿဖစ္သည္။

void Fn (int arg1=0,int arg2=1000);

viod Fn ( int =0, int=1000);

အထက္ေဖာ္ၿပပါ prototype နွစ္ခုစလံုးသည္ အတူတူပင္ၿဖစ္သည္။
အကယ္၍ function ၏ မတည္ရွိေသာ argument အစိတ္အပိုင္းအား call ေခၚမိေသာအခါ , complier သည္ argument list ၏ ေနာက္ဆံုးတြင္ရွိေနေသာ argument အား တြက္ခ်က္လိမ့္မည္ၿဖစ္သည္။

Fn();             //arg1=0,arg2=1000
Fn(10);         //arg1=10,arg2=1000
Fn(10,99);     //arg1=10,arg2=99

Default argument မ်ားသည္ constants (သို႕) global variable မ်ားၿဖစ္ရမည္ၿဖစ္သည္။

translated by zmk@miet51