How C++ Objects are referenced

1. The code

Code:

myObj = new object_type();

is illegal, so the program did not compile, and execution cannot happen.

2. In myFunctionReference, no copying is performed by the call. The assignment operator is called inside the function. In myFunctionArgument, arg1 is constructed "during" the function call (i.e., before the flow of control is handed off to the function), then myObj is changed by the assignment operator, then arg1 is destructed before flow of control returns to the caller.

For the first, you need a pointer. At the declaration, the constructor for object_type* (NOT object_type!) will be called.
The constructor for object_type will be called at the
MyObj = new object_type()
line. Then the address of that object (object_type*) will be assigned to MyObj. This will call the built-in assignment operator for object_type*.

Originally Posted by tabstop

1. The code
[code]
In myFunctionArgument, arg1 is constructed "during" the function call (i.e., before the flow of control is handed off to the function), then myObj is changed by the assignment operator, then arg1 is destructed before flow of control returns to the caller.

Thanks!! That was the answer I was looking for. So it seems passing objects without references is a much object-oriented and cleaner way of doing things. On the other hand, it's not very efficient.
In Java, function calls are passed by reference 1) to make things more efficient 2) elminate the confusion for the programmers.

Also yes I had a few typos. the myObj = new object_type would not have compiled. I meant to say this:

Code:

object_type myObj; //global delcaration because I need to initialize it within the case statement in WM_CREATE.
...
WM_CREATE:
object_type myObj= object_type(dcHandle);

It just occured to me that when I declare it, a copy was made. At the WM_CREATE, I have the object constructed it again. Yes one would argue that poniters would make things more efficient but I have to keep track of the dcHandle. Anyhow I'll just use pointers and add a destructor.

Originally Posted by derder

So it seems passing objects without references is a much object-oriented and cleaner way of doing things.

That is not really true. Inheritance and polymorphism form a fairly significant part of object oriented programming, yet OO polymorphism in C++ takes place through pointers and references. If your parameter is of a base class type, and not a pointer or reference thereof, you would get type slicing instead of the (presumably) desired polymorphism.

Originally Posted by derder

In Java, function calls are passed by reference 1) to make things more efficient 2) elminate the confusion for the programmers.

No, in Java, function arguments are passed by value, but because the variables concerned are of Java reference types, you get a call by reference mechanism. Java reference types are actually more like pointers without pointer syntax.