C ++ Reference Parameters Versus Java Reference Parameters

By: Abinaya Viewed: 153207 times  Printer Friendly Format    


The C++ pointer parameter, In Java, became a reference parameter. Of course, C++ also supports reference parameters. As mentioned, most pointer parameters found in C++ code are simply holdovers from C. Nearly all new C++ code will use reference parameters when a function needs access to the argument, itself. (In essence, pointer parameters, although still common, are actually anachronisms in most C++ code.) Since both Java and C++ support reference parameters, you might think that the conversion of a C++ function that uses reference parameters to a Java method would involve few changes. Unfortunately, this is not always the case. To understand why, let's convert the following C++ program, which swaps the contents of two Coord objects using reference parameters:

// Swap coordinates — C++ version.
#include <iostream>
using namespace std;
class Coord {
public:
int x;
int y;
};
// Swap contents of two Coord objects.
void swap(Coord &a, Coord &b) {
Coord temp;
// swap contents of objects
temp = a;
a = b;
b = temp;
}
int main()
{
Coord ob1, ob2;
ob1.x = 10;
ob1.y = 20;
ob2.x = 88;
ob2.y = 99;
cout << "Original values:\\n";
cout << "ob1: " << ob1.x << ", " << ob1.y << "\\n";
cout << "ob2: " << ob2.x << ", " << ob2.y << "\\n";
cout << "\\n";
swap(ob1, ob2);
cout << "Swapped values:\\n";
cout << "ob1: " << ob1.x << ", " << ob1.y << "\\n";
cout << "ob2: " << ob2.x << ", " << ob2.y << "\\n";
return 0;
}

Following is the output produced by this program. As you can see, the contents of ob1 and ob2 have been exchanged:

Original values:
ob1: 10, 20
ob2: 88, 99
Swapped values:
ob1: 88, 99
ob2: 10, 20

In Java, all objects are accessed via an object reference variable. Thus, when an object is passed to a method, only its reference is passed. This means that all objects are automatically passed by reference to a Java method. Without thinking any deeper about what is actually occurring, someone might initially try the following (incorrect) conversion of the preceding program:

// Swap program incorrectly converted to Java.
class Coord {
int x;
int y;
};
class SwapDemo {
static void swap(Coord a, Coord b) {
Coord temp = new Coord();
// this won't swap contents of a and b!
temp = a;
a = b;
b = temp;
}
public static void main(String args[]) {
Coord ob1 = new Coord();
Coord ob2 = new Coord();
ob1.x = 10;
ob1.y = 20;
ob2.x = 88;
ob2.y = 99;
System.out.println("Original values:");
System.out.println("ob1: " +
ob1.x + ", " + ob1.y);
System.out.println("ob2: " +
ob2.x + ", " + ob2.y + "\\n");
swap(ob1, ob2);
System.out.println("Swapped values:");
System.out.println("ob1: " +
ob1.x + ", " + ob1.y);
System.out.println("ob2: " +
ob2.x + ", " + ob2.y + "\\n");
}
}

The output produced by this incorrect program is shown here:

Original values:
ob1: 10, 20
ob2: 88, 99
 

Swapped values:
ob1: 10, 20
ob2: 88, 99

As you can see, the values of ob1 and ob2 in main() have not been exchanged! Although a bit counterintuitive at first, the reason is actually obvious, once you understand precisely what happens when an object reference is passed to a method. Java passes all arguments to methods using call-by-value. This means that a copy of the argument is made, and what occurs to the copy inside the method has no effect on the argument used to call the method. However, this situation is blurred a bit in the case of object references.

When an object reference is passed to a method, a copy of the reference variable is made, as just explained. This means that the parameter inside the method will refer to the same object as does the reference variable used as an argument outside the method. Therefore, operations on the object through the parameter will affect the object referred to by the argument (since they are one and the same). But operations on the reference parameter, itself, affect only that parameter. Thus, when the preceding program attempts to swap the objects by exchanging the objects pointed to by a and b, all that is happening is that the parameters (that is, the copies of the arguments) are exchanging what they are referring to, but this does not alter what ob1 and ob2 refer to back in main().

To fix the program, swap() needs to be rewritten so that the contents of the objects are exchanged, not what the p arameters refer to. Here is the corrected version of swap():

// Corrected version of swap().
static void swap(Coord a, Coord b) {
Coord temp = new Coord();
// swap contents of objects
temp.x = a.x;
temp.y = a.y;
a.x = b.x;
a.y = b.y;
b.x = temp.x;
b.y = temp.y;
}

If you substitute this version of swap( ) into the preceding program, the correct results will be achieved.



Most Viewed Articles (in C++ )

Latest Articles (in C++)

Comment on this tutorial