c++ Reference Parameters Versus Java Reference Parameters
In the preceding section, you saw an example of a C++ program that used a pointer
parameter. In Java, this 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 Cooed objects using reference parameters:
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’ arc 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:
As you can see, the values of obl and ob2. in main( ) have not been exchanged I Although a bit counter intuitive 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 obl and ob2 refer to back in main( ). To fix the program, swapt ) needs to be rewritten so that the contents of the objects are exchanged, not what the parameters refer to. Here is the corrected version of swap.