How objects are stored

I was wondering about this:

Code:

MyObject obj1;
MyObject obj2;
obj1 = obj2;

In Java (which is the OO programming language I am used to), this would cause both variables to point to the same object in memory, and cause obj2 to be garbage collected.

A don't know if in C++ it will do what Java does or make obj2 an independent duplicate of obj1? And if so, how do you make two variables point to the same object?

Assuming that MyObject has normal copying semantics, that would cause obj1 to be a copy of obj2. They are nonetheless different objects.

So, for example, if MyObject had a field "x", then continuing from my above example setting obj1.x = 5 would not make obj2.x == 5, right?

Originally Posted by MTK

So, for example, if MyObject had a field "x", then continuing from my above example setting obj1.x = 5 would not make obj2.x == 5, right?

Right. It's copy constructed. If you wanted that behavior, you'd have to explicitly state it with a reference (&) or pointer (*) or something. Also given these are normal objects they will be destroyed at the end of the scope, freeing the memory. If you allocated the memory with malloc or new then you'd have to worry about collecting your own garbage (or use a smart pointer, etc). You get the idea.

Originally Posted by Dae

It's copy constructed.

In this case copy assignment, not copy construction, is used.

And in a case where I need the Java-like behavior, I guess should use pointers.

Originally Posted by MTK

And in a case where I need the Java-like behavior, I guess should use pointers.

To get closer to Java you probably want reference-counted smart-pointers, like shared_ptr.

Originally Posted by MTK

And in a case where I need the Java-like behavior, I guess should use pointers.

Depends. You should prefer references to pointers where possible. References have the limitation that they cannot be reassigned to refer to something else.

I read about references, and it says that once the scope of the originally declared variable runs out, all references will be invalid. Is there a way to avoid this?

Originally Posted by MTK

I read about references, and it says that once the scope of the originally declared variable runs out, all references will be invalid. Is there a way to avoid this?

How is that different from a pointer? A reference is just a pointer with different, sometimes-nicer-to-use language semantics.

If you pass a pointer to a local variable to a function that runs in another thread, and original function finishes execution, the local variable will be destroyed and what the pointer in the thread then contains is undefined.
Same thing with references.

Is that not what you're referring to?

I'm just very strongly used to Java's way where all objects are actually references, and the object is destroyed only when all references are gone, not when the original reference went out of scope.

That is exactly what smart pointers do.

I find Java's references to be a real pain and a mess. They act like some reference-pointer hybrid.
C++ is the real deal, I would say, since using the == operator can actually compare the objects instead of the pointers (comparing two references compares the two objects).
You can also choose whether to check the pointers for equality or the objects themselves.

Doesn't Java's way use less CPU and memory because it doesn't do all that copying?

Originally Posted by MTK

Doesn't Java's way use less CPU and memory because it doesn't do all that copying?

Oh lord. All it does is copy a 4 byte pointer. That's nothing compared to what Java does behind the scenes. C++ is quick, as in very quick. You don't really need to second guess the compiler very often.

I thought C++ copies the whole object, not just a pointer.