Pass by value vs Pass by reference

முந்தைய பாகத்தில் Named and Optional Arguments என்றால் என்னவென்று பார்த்தோம் அல்லவா? ஒரு procedure ரையோ அல்லது function னையோ call செய்யும்போது இரண்டு வழிகளில் அவற்றிற்கு நாம் arguments களை அனுப்பலாம். அவை Pass by value மற்றும் Pass by reference எனப்படும். அதைப்பற்றி இந்த பாடத்தில் பார்ப்போம்.

குறுக்கெழுத்துப்போட்டி அச்சிடப்பட்ட தாளை வைத்துக்கொண்டு உங்கள் வீட்டு திண்ணையில் உட்கார்ந்து கொண்டிருக்கிறீர்கள். பதில்களை நிரப்ப ஆயத்தமாகும்போது எதிர்வீட்டு நண்பர் வருகிறார். ஆசையா இருக்குப்பா! நானும் பதில் எழுதறேனே, எனக்கும் கொஞ்சம் கொடேன் என்று கேட்கிறார்.

நீங்கள் அந்த தாளை அவரிடம் கொடுக்கிறீர்கள். அவர் விடைகளை எழுதுகிறார். பின்னர் அந்த தாளை உங்களிடம் தந்துவி்ட்டார்.

இப்பொழுது சொல்லுங்கள். உங்கள் கையில் இருக்கும் தாளில் உங்கள் நண்பருடைய பதில்கள் இருக்குமா? இருக்காதா?

இருக்கும்.

சரியான பதில். எதனால் இருக்கிறது?

ஏன்னா, நான் என்னுடைய தாளையல்லவா கொடுத்தேன். அதில் அவர் மாற்றம் செய்தால் அது இருக்கத்தானே செய்யும்! 

மிகச் சரியாக சொன்னீர்கள்.

சரி அடுத்த கேள்வி.

ஒருவேளை நீங்கள் அந்த தாளை ஒரு நகலெடுத்து அவரிடம் கொடுக்கிறீர்கள் என்று வைத்துக்கொள்வோம். அதில் அவர் விடைகளை எழுதுகிறார்.

உங்களிடம் உள்ள தாளில் அவருடைய பதில் இருக்குமா?

இருக்காது.

ஏன் உங்களுடைய தாளில் அவருடைய பதில் இல்லை?

ஏன்னா, நான் காப்பியைத்தானே கொடுத்தேன். ஒரிஜினல் என்கிட்டதானே இருக்கு. அவர் அந்த தாளில் மாற்றினால் அது எப்படி இந்ததாளில் இருக்கும்.

மிகச் சரியாக சொன்னீர்கள்.

மேற்கண்ட இரண்டு வழிகளில் எந்த வழியை எப்பொழுது தேர்ந்தெடுப்பீர்கள்?

நாங்கள் இரண்டு பேரும் சேர்ந்து குறுக்கெழுத்துபோட்டிக்கு பதில் எழுதனும்னு தோன்றினால் ஒரு தாளையே பகிர்ந்துகொள்வேன்.

அல்லது நண்பர் எழுதிய பதில் எனக்குத் தேவையில்லை என்று தோன்றினால் ஒரு நகலெடுத்து கொடுத்துடுவேன்.

மிகச்சரியாக சொன்னீர்கள்.

இதை நம் பாடத்தோடு பொருத்தி பார்த்தால் இப்படி உருவகப்படுத்தலாம்.

Main Program - நீங்கள் 
Sub Program / Procedure / Function - உங்கள் நண்பர்

Parameter / Formal Parameter - உங்கள் நண்பர் எதிர்பார்ப்பது

Argument / Actual parameter - நீங்கள் கொடுக்கும் குறுக்கெழுத்து தாள்

Passing method - குறுக்கெழுத்து தாளை அவருக்கு கொடுக்கும் முறை

நீங்கள் தேர்ந்தெடுத்த வழிகளை இப்படி உருவகப்படுத்தலாம்.

நீங்கள் உங்கள் நண்பருக்கு உங்கள் தாளையே பகிர்ந்து கொடுக்கிறீர்கள்.
Main Program sends a reference of a variable to Sub Program

நீங்கள் உங்கள் உண்பருக்கு உங்கள் தாளை நகலெடுத்து கொடுக்கிறீர்கள்.
Main Program sends a copy / value of a variable to Sub Program

நீங்கள் தேர்ந்தெடுக்கும் முதல் வழிக்கு பெயர்தான் Pass by reference

நீங்கள் தேர்ந்தெடுக்கும் இரண்டாம் வழிக்கு பெயர்தான் Pass by value

இரண்டிற்கும் வித்தியாசம் புரிந்ததா? உங்களுடைய தேவைக்கு தக்கவாறு ஒரு வழியை நீங்கள் தேர்ந்தெடுத்துக்கொள்ளலாம்தானே?

Formal Parameter 

Formal parameter என்பது procedure definition னில் இருப்பது. அதாவது ஒரு procedure ரையோ அல்லது ஒரு function னையோ declare செய்யும்போது இன்னன்ன parameter இதற்கு தேவை என்று குறிப்பிடுவது Formal parameter ஆகும்.

Actual parameter

Actual parameter என்பது procedure ரையோ அல்லது function னையோ call செய்யும்போது நாம் கொடுக்கும் input value வாகும்.

Pass By Reference

1. Actual parameter variable லுடைய address, formal parameter ருக்கு அனுப்பப்படுகிறது. இதனால்  Actual Parameter ரும் formal parameter ரும் ஒரே memory address ஸை பயன்படுத்துகின்றன. (நாங்கள் இரண்டு பேரும் சேர்ந்து குறுக்கெழுத்துபோட்டிக்கு பதில் எழுதனும்னு தோன்றினால் ஒரு தாளையே பகிர்ந்துகொள்வேன் என்ற பதிலை ஞாபகப்படுத்தி கொள்ளவும்.)

2. sub program / function அந்த formal parameter value வை மாற்றினால் அது actual parameter ரைத்தான் மாற்றுகிறது.
  
3. ஒரு function 1 value வைத்தான் return செய்யும் என்கிற விதியை மாற்றி எத்தனை value வை வேண்டுமானாலும் return செய்யவைக்கலாம். அதாவது எத்தனை pass by reference பயன்படுத்துகின்றோமோ அத்தனை value க்கள் return செய்யப்படும்.  (நமது உதாரணத்தில் இருக்கும் FnReturnTwoValues என்கிற function ஐ பார்க்க)

4. ஒரு procedure எதையும் return செய்யாது என்கிற விதியை மாற்றி எத்தனை value வை வேண்டுமானாலும் return செய்யவைக்கலாம். அதாவது எத்தனை pass by reference பயன்படுத்துகின்றோமோ அத்தனை value க்கள் return செய்யப்படும். (நமது உதாரணத்தில் இருக்கும் GetBigestNoProc என்கிற procedureஐ பார்க்க)

5. Memory address share பண்ணப்படுவதால் variable களை மட்டும் தான் actual parameter ராக அனுப்பமுடியும். Value க்களை அனுப்ப முடியாது. 

Pass By Value:

1. Actual parameter variable லுடைய value, formal parameter ருக்கு அனுப்பப்படுகிறது. இதனால்  Actual parameter ரும் formal parameter ரும் வெவ்வேறு memory address களை பயன்படுத்துகின்றன. (அவன் எழுதிய பதில் எனக்குத் தேவையில்லை என்று தோன்றினால் ஒரு பிரதியெடுத்து கொடுத்துடுவேன்என்ற பதிலை ஞாபகப்படுத்தி கொள்ளவும்.)

2. Sub program / function அந்த formal parameter value வை மாற்றினால் actual parameter மாறாது.
  
3. Variable, value என்று எதை வேண்டுமானாலும் actual parameter ராக அனுப்பமுடியும் 

உதாரணத்திற்கு அடுத்து வரும் புரோகிராமை பார்க்கவும்

procedure Main;
var
  Val1, Val2 : Integer;
  Val3, Val4 : Integer;
begin
  Val1 := 10;
  Val2 := 20;
  Val3 := 0;
  Val4 := Val3;

  //call function to get biggest among 2 numbers
  Val3 := GetBigestNoFn ( Val1, Val2 );
  Print Val1, Val2, Val3, Val4;

  //call procedure to get biggest among 2 numbers!
  //pass by reference மூலம் இங்கே procedure 
  //ஒரு value வை return செய்வது போன்ற தோற்றத்தை ஏற்படுத்த முடிகிறது. 
  GetBigestNoProc ( Val1, Val2, Val3 );
  Print Val1, Val2, Val3, Val4;

  //One function return more than one value!
  //pass by reference மூலம் இங்கே function
  //more than 1 value வை return செய்வது போன்ற தோற்றத்தை ஏற்படுத்த முடிகிறது. 
  Val4 := FnReturnTwoValues ( Val1 )
  Print Val1, Val2, Val3, Val4;
end;

function GetBigestNoFn ( ByVal1, ByVal2 : Integer ) : Integer;
begin
  If ByVal1 > ByVal2
  then Result := ByVal1
  else Result := ByVal2;
end;

procedure GetBigestNoProc ( ByVal1, ByVal2 : Integer; Var ByRefBigNum : Integer );
begin
  //pass by reference value is modified
  If ByVal1 > ByVal2
  then ByRefBigNum := ByVal1
  else ByRefBigNum := ByVal2;
 
  //pass by values are modified
  //but it will not affect actual paramters
  ByVal1 := ByVal1 + ByVal1;
  ByVal2 := ByVal2 + ByVal2;
end;

function FnReturnTwoValues ( Var ByRefRetVal : Integer ) : Integer;
begin
  ByRefRetVal := ByRefRetVal * 2;
  Return := ByRefRetVal * 2;
end;

இந்த புரோகிராம் எப்படி வேலை செய்கிறது என்பதை விளக்கும் படத்தை கீழே காண்க