Wednesday, November 15, 2006

Pass by Value and Pass by Reference

Topics

• Pass by value
• Pass by value is used to copy a value from the calling function into the called function.  It applies to the formal parameters In your function definition.
• Pass by value means that the value goes into the function by a copy.  The original value in the calling function is not changed.
• A pass by value formal parameter is often referred to as an "in only" parameter.
• You can use either constants or variables for the arguments in the function call.
• In Java, all intrinsic data types are always pass by value.  Objects, including arrays, are never pass by value.
• In C and C++ you have a choice of pass by value and pass by reference (discussed below) for all data types and classes, except arrays.
• Example: A swap function using pass-by-value would not actually swap the values in the calling function.:
•    void callingfunction()
•     {
•         int a = 5; b = 3;
•    
•         // output the values in a and b
•         swap(a, b);
•         // output the values in a and b
•     }
•    void swap(int x, int y)
•     {
•         int temp;
•        
•         // output the values in x and y       
•         temp = x;
•         x = y;
•         y = temp;
•         // output the values in x and y       
•     }
• In both Java, C, and C++, the values for a and b would be the same before and after the swap.  a would be 5 and b would be 3.  However the values for x and y inside the swap function would change.  The first output would be 5 for x and 3 for y.  The second output would be 3 for x and 5 for y. 
• Since x and y are local variables inside the swap function, with just copies of the values in a and b, the swap would only affect those copies in x and y, not the original values in a and b in the calling function.
•  
•  
• Pass by reference
• Pass by reference uses a reference to the original variable in the calling function.  This reference is really just another name for the original variable inside the function.  The reference is used as if it were a local variable, but actually it is the variable passed as an argument in the calling function.
• Any changes to the pass by reference variable inside the function is really a change to the original variable in the calling function.
• A pass by value formal parameter is often referred to as an "in / out" parameter. or sometimes an "out only" parameter.
• Pass by reference parameters are always called using a variable as the argument.  You can't try to pass a constant by reference in a function call.  A constant can not be changed, so the compiler would give an error if you try to pass it by reference.
• In Java, all objects, including arrays, are always pass by reference.  Intrinsic data types are never pass by referebce.
• Objects are always pass by reference in Java because the object names themselves are always references.
• Java does not require any additional syntax to indicate pass by value or pass by reference, because you don't have a choice as the programmer which will be used.  Intrinsic data types are always pass by value.  Objects and arrays are always pass by reference.
• In C and C++ you have a choice of pass by value and pass by reference for all data types and classes, except arrays.
• The syntax for pass by reference in C++ is just the addition of an ampersand, &, after the data type in the formal parameter.  No other syntax is needed in C++.
• Example: Now this swap function will actually swap the values in the calling function.  The function, however is valid only in C++.  In Java or pure C you would get a compiler error.
•    void callingfunction()
•     {
•         int a = 5; b = 3;
•    
•         // output the values in a and b
•         swap(a, b);
•         // output the values in a and b
•     }
•    void swap(int& x, int& y)
•     {
•         int temp;
•        
•         // output the values in x and y       
•         temp = x;
•         x = y;
•         y = temp;
•         // output the values in x and y       
•     }
• Now the values for a and b will be different before and after the swap.  a would be 5 and b would be 3 before and a would be 3 and b would be 5 after the call to swap.  The values for x and y inside the swap function would also change because they are just references to a and b, which are the real variables that are being manipulated inside the swap function. The first output would be 5 for x and 3 for y.  The second output would be 3 for x and 5 for y. 
• C and C++ also have another way to pass by reference.  The syntax uses pointers which are indicated by an asterisk, *, character.  The syntax is more complicated, and beyond the scope of this course.
• In C your only choice to pass by reference is using the pointers and asterisks.
•  

Readings