Parameter Passing
Published: 2022-06-25 07:46:12

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

Formal parameter ဆိုတာက subprogram ထဲမှာပါတဲ့ parameter ကိုပြောတာ
Actual parameter ဆိုတာက subprogram ကိုခေါ်တဲ့အချိန် မှာထည့်ပေးလိုက်တဲ့ဟာကိုခေါ်တယ်။ Actual parameter ကို Arguments လို့လဲေခါ်ကြပါတယ်။
#### Example of formal parameters
```java
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)
 ```java
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
```C++
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
```C++
#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.

```C++
#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
{% replit @HeinKhantZaw/Parameter-passing-example %}