Parameter Passing

Parameters ဆိုတာက subprogram (subprogram ဆိုတာက C++ မှာဆို function, Java မှာဆို Methods) ထဲမှာ သုံးဖို့အတွက်‌ထည့်ပေးလိုက်တဲ့ တန်ဖိုး(or) subprogram ကနေတွက်ထုတ်‌ေပးလိုက်တဲ့တန်ဖိုး ကိုခေါ်တယ်။

Formal parameter ဆိုတာက subprogram ထဲမှာပါတဲ့ parameter ကိုပြောတာ
Actual parameter ဆိုတာက subprogram ကိုခေါ်တဲ့အချိန် မှာထည့်ပေးလိုက်တဲ့ဟာကိုခေါ်တယ်။ Actual parameter ကို Arguments လို့လဲေခါ်ကြပါတယ်။

Example of formal parameters

public int addTwoNum(int a, int b) // a and b are formal parameters
{
   int c = a + b; // a, b are input parameters
   return c; // c is output parameter
}

Example of actual parameters (a.k.a Arguments)

int num1 = 1, n2 =2;
int sum = addTwoNum(num1, num2); //num1 and num2 are actual parameters

အဲ့တော့ subprogram တစ်ခုကိုခေါ်မယ်ဆိုရင် ဘယ်လိုဖြစ်သွားသလဲဆိုတော့
actual parameter ထဲကတန်ဖိုးကို formal parameter ထဲလွဲပေးလိုက်တယ်။
subprogram က သူ့ထဲက formal parameter နဲ့ပဲအလုပ်လုပ်တယ်။
အပေါ်က code မှာဆိုရင် num1, num2 ကို addTwoSum() ထဲထည့်ပေးလိုက်
တာတွေ့တယ်မလား။ အဲ့ num1, num2 ထဲက တန်ဖိုးက addTwoNum()
ထဲရောက်သွားတော့ a, b အနေနဲ့ပဲ calculation လုပ်သွားတယ်။
ဒီလောက်ဆို formal နဲ့ actual ကိုကွဲပြီထင်တယ်။

Input, Output, Input/Output

Input parameter က subprogram ကလက်ခံတဲ့ parameter ကိုခေါ်တာ။
အပေါ်က formal parameters example မှာပြထားတဲ့ a နဲ့ b ဆိုတာက input parameter ပဲ ။

Output parameter ကျတော့ subprogram ကနေ ပြန်ထုတ်ပေးလိုက်တဲ့ parameter ကိုခေါ်တာ။
Eg. အပေါ်က addTwoNum() မှာဆိုရင် c က output parameter ဖြစ်တယ်။

Input/Output parameters ကတော့ subprogram ကလက်ခံထားတဲ့ input parameter ကိုပဲ output parameter အဖြစ် ပြန်ထုတ်ပေးတာကို Input/Output parameter လို့ခေါ်တယ်။
ဆိုလိုချင်တာက input ကိုပဲတန်ဖိုးပြောင်းပြီး ပြန်ထုတ်ပေးလိုက်တာမျိုးကိုပြောတာ။

input/output parameters က callByReference မှာ‌‌သုံးလို့ရတယ်။

Example of input/output parameters

public int addTwoNum(int &a,int &b) 
{
   a = a + b;
   return a; // a is input/output parameter
}

Value or Reference?

Parameter pass တဲ့အခါမှာ အသုံးအများဆံုးက value pass တာနဲ့ reference ကို pass တာဆိုပြီး နှစ်မျိုးရှိတယ်။

Call by Value

Call by Value ဆိုတာက subprogram ထဲကို parameter pass
ပေးတဲ့အခါ ဟိုအပေါ်မှာ‌ေြပာထားသလိုပဲ actual parameter ရဲ့ တန်ဖိုးကို formal parameter ထဲ လွှဲပေးလိုက်တာ။
အဲ့တော့ subprogram ထဲမှာလုပ်သမျှတွေသည် actual parameter ကို ဘာမှလာမပြောင်းလဲစေဘူး။
formal parameter ကပဲပြောင်းသွားလိမ့်မယ်။

Example of Call by Value

#include <iostream>
using namespace std;

void increaseByValue(int n){
  n++; // n = 2
}

int main() {
  int num = 1;
  increaseByValue(num); // This won't change the value in num
  cout<<"After Passing by value :"<<num<<'\n'; // num = 1
}
// Since it's call by value, you'll need to return the value or else, there won't be any effect. 

ဒီ code ထဲမှာဆိုရင် increaseByValue() က n တန်ဖိုးကို 1 တိုးပေးတယ်။
subprogram တွေက သူတို့အလုပ်ပြီးသွားတာနဲ့
formal parameter ကို destroy လုပ်လိုက်တယ်။
eg. variable n ရဲ့ scope က increaseByValue() အတွင်းမှာပဲရှိတယ်
အဲ့တော့ သူ့ထဲကတန်ဖိုးက increaseByValue() ရဲ့အလုပ်ပြီးရင် အပြင်က main function ကိုရောက် မသွားဘူး။
Main function ထဲကိုရောက်ချင်ရင် အဲ့ n ကို output parameter အဖြစ် return ပေးမှပဲရလိမ့်မယ်။
example code မှာက function return ကို void ထားတော့ဘာမှ return မလုပ်ဘူး။
အဲ့တော့ ဘယ်လိုဖြစ်သွားလဲဆိုတော့ increaseByValue(num)
လုပ်လိုက်တဲ့အခါ n တန်ဖိုးက ၂ တော့ဖြစ်သွားတယ်။
ဒါပေမယ့် num ရဲ့တန်ဖိုးက ၁ က ၁ ပဲ။ မပြောင်းသွားဘူး။
တကယ်လို့ num မှာပါလာပြောင်းချင်တယ်ဆိုရင်
increaseByValue() မှာ n ကို return ပေးမှရမယ်။

I'll show the correct way in this example.

#include <iostream>
using namespace std;

int increaseByValue(int n){
  n++; // n = 2
  return n;
}

int main() {
  int num = 1;
  num = increaseByValue(num); // This won't change the value in num
  cout<<"After Passing by value with return statement :"<<num<<'\n'; // num = 1
}
// Since it's call by value, you'll need to return the value or else, there won't be any effect. 

Call by reference

Call by Reference ကျတော့ actual parameter ကနေ formal parameter
ထဲတန်ဖိုးလွှဲပေးလိုက်တဲ့အခါမှာ value အစား memory address ကိုလွှဲပေးလိုက်တာ။
Variables ရဲ့ တန်ဖိုးတွေက memory address မှာသိမ်းတာတော့သိတယ်မလား။ အဲ့ address ကိုလွှဲပေးလိုက်တော့ subprogram က အဲ့ variable ကို directly access ရသွားတယ်။ call by value တုန်းကလို တစ်ဆင့်ခံမဟုတ်တော့ဘဲ အဲ့တန်ဖိုးသိမ်းထဲတဲ့နေရာကိုယူပြီး calculationsလုပ်လို့ရသွားတာ။ အဲ့တော့ ဘာကွာလဲဆိုတော့ callByReference မှာဆိုရင် return လုပ်စရာမလိုဘဲ actual parameter ရဲ့ တန်ဖိုးကိုပြောင်းလို့ရသွားလိမ့်မယ်။

Example ကိုဘာလို့C++နဲ့ရေးလဲဆိုေတာ့....

Java doesn't support call by reference, so, I wrote it in C++.

Example of Call by Value and Call by Reference