Re: How java passes object references?
pek wrote:
Correct me if I'm wrong anywhere. This is what I think. Suppose we
have the following code:
...
Human h; // (1)
h = new Human(); // (2)
change(h);
...
public void change(Human o) { // (3)
o = new Human(); // (4)
}
In Java:
Assuming no optimization, either at runtime or compile-time:
1. Allocates a small memory block which will be used to point to an
object of type Human
Saves a space in the local variable registers of the function for h.
2. Allocates memory for the newly create Human object and changes the
value of the memory block of reference h (which was previously null)
to point to the new Human
Constructs a new `Human' object, preinitializes it, calls the
constructor, and then marks the local variable register as pointing to it.
3. When called, it allocates memory for the local reference variable o
and copies the pointer of the passed reference, thus, both the called
and the local point at the same object
The argument causes a space in the local variable register for the
function change. In the process of the call, this register is set to the
same value of h, i.e., the handle to the actual `Human' object.
4. Allocates memory for the newly created Human object and changes the
pointer of the local reference o to it, thus, any changes to o don't
affect the passed reference (h).
Does the same thing as Step 2 to the local variable register in the
function change. Since the register is merely a handle to the object,
the two registers here (`h' and `o') now point to different objects.
So, right before the method change() ends, the memory would allocate:
two memory blocks for each object (the one from main and the one from
change) and two reference variables that have pointers that point to
each object.
The "reference variables" are probably allocated on the stack and not
the heap, so the term `allocation' doesn't apply there, but otherwise
correct.
Because I don't know C++, I'll use the code from Java and talk about
memory allocation as I think. So, in C++:
C++ version (I am assuming you want the incorrect translation that
changes Java's pass-by-value to a pass-by-reference, from your subject;
I'm also assuming stack variables for pass-by-reference as opposed to
heap-allocated variables):
....
Human h;
change(h);
....
void change(Human &o) {
// Not quite the same, since I'm invoking a copy constructor here.
o = Human();
}
1. Nothing happens, I don't know if this actually works. I don't know
how pointers work in memory.
`Human h;' declares a variable h, on the stack, of the class `Human' and
calls the default constructor of h.
2. Again, memory is allocated for the newly created object and now h
is a pointer pointing at the memory block.
[ Folded into #1 under my assumed C++ version. ]
Stack -> no memory allocation, unless Human does so.
3. When called, the memory location of the passed pointer will copied
to o, thus, both pointing at the same object
Technically, what happens is that the argument `o' is made an alias to
object `h'. Practically, the references are translated to pointers at
runtime, so that `o' in some way refers to the address of `h'. ISO C++
gives compilers a lot of latitude in terms of how references are
actually implemented.
4. ??? What happens here???? h and o are both pointers that point to
the same object. If I change o to point to another object, how does h
know about it? What about the previous object?
`h' and `o' are effectively different names for the same objects. So `&h
== &o' should be true throughout the entire function `change'.
Effectively, what the translated C++ version is doing is creating a new
`Human' object, and assigning it via the copy constructor to the slot to
which `h' and `o' both point.
So, right before change() ends the memory allocates: two objects for h
and o (with no pointers at h, and now it must be garbage
collected....which won't) and....what? Two pointers? Does a pointer
allocate memory?
C++, at least without external libraries, doesn't have garbage
collection. Anyways, two constructions of `Human' occur (since I've
elicited pointers from the C++ example, allocation per se doesn't
occur), whereas the two variables are both referring to the same
location of memory. Both of the variables are on the stack, however, and
typically don't count as allocation.
Am I right about the memory allocations in the Java code? What about
pointers in C++? Do they allocate any memory space? If they don't, how
does it store the pointers memory location? What are pointers in terms
of memory?
Modulo the difference between stack and heap, you are right.
I hope I made my questions as clear as possible. Unfortunately, I
can't post an image to illustrate my point. I'm trying to create a
slide about Pass-by-value, Pass-by-reference and Pass-reference-by-
value. So I need this information in order to create a good
illustration of the concepts (which unfortunately I didn't find
anywhere on the internet).
Roedy's site is probably the best online explanation of
pass-by-value/pass-by-reference, at least for Java, if not for most
languages in general.
--
Beware of bugs in the above code; I have only proved it correct, not
tried it. -- Donald E. Knuth