Thread: How C++ Objects are referenced

Hello,
I have a class that is instantiated as follows:

DCManager dcManager;
...
WM_CREATE:
dcManager= DCManager(dcImage);

It seems the compiler complaines that there's no default constructor when I use the following code "DCManager dcManager". This tells me that "DCManager dcManager" instantiates an instance during the declaration which is not I wanted.

Question 1. In my code above, an instance is created during the declaration, so in my WM_CREATE, another instance is created. That means the first instance is explictly deleted? That is, the default constructor is called when the dcManager=DCManager(dcImage) creates another instance?

Now, I have my code as follows:

DCManager dcManager=NULL;
QueueHolder queueHolder=NULL;
...
WM_CREATE:
dcManager= DCManager(dcImage);
queueHolder = QueueHolder(dcManager);

Question 2: In the code above, is the dcManger passed as a reference or another copy is made when the queueHolder = QueueHolder(dcManager) is called?


Question 3: I want to debug to see if the deconstructor for the DCManager is coded correctly. Can I explictly use delete the dcManager instead of waiting for it to go out of scope:

WM_CREATE:
dcManager= DCManager(dcImage);
queueHolder = QueueHolder(dcManager);
WM_DESTROY:
delete dcManager;
delete queueHolder;

I suppose the first question is what else you think "DCManager dcManager" could be other than the creation of a variable/object -- unless you've typedef'ed DCManager to be a pointer type (which is Evil), but then the compiler wouldn't complain, because in that case dcManager wouldn't be an object.

If there is no default constructor then I don't know how version 1 even compiles. If you created a default constructor, then the last line of the version 1 code would create a temporary object using dcImage, then copy that object into the previously constructed object (assuming lack of Evil as above).

There is no way to know the answer to question 2, as it depends on the function. "DCManager" and "reference to DCManager" (DCManager&) are different types, and whichever one the function calls for in the prototype is the one it uses. (Again, are DCManager and QueueHolder typedef'ed to pointers?)

If you created a default constructor, then the last line of the version 1 code would create a temporary object using dcImage, then copy that object into the previously constructed object (assuming lack of Evil as above).

Ok, so I added a default constructor after the compiler complains. In the WM_CREATE method, what happens when I create another object dcManager= DCManager? Is the previous dcManager created during my declaration automatically deleted?

Question 2 can be ignored because I was too vague.

I am still curious on my question 3. If i don't use the delete dcManager, I know the dcManager will be deleted when it's out of scope. However, can I explicitly delete it? I want to see how the desconstructor remove the device context, and use a few routine to test if the device context are deleted properly.

I was too vague on the pass by reference with question 2. Here's what I meant:

Code:

public:
 MYObj myObj;

OutputManager::OutputManager(MyObj &_myObjArg) {
	myObj= _myObjArg;
}

Is MYObj objected created during my declaration? Is myObj an object? Is so what happens during assignment such as myObj= _myObjArg?

myObj1 is a real honest-to-goodness thing; no pointers anywhere in the whole thing.

Originally Posted by laserlight

Basically, you used a constructor for DCManager other than the default constructor. Passing NULL to the constructor in that way is misleading because dcManager is not a pointer (or pointer-like); you could have written:

Code:

DCManager dcManager(0);

I initially asked if objects are created in my declaraton:

Code:

DCManager dcManger;

You said no. However reading your quote above, it seems you need to add a default constructor. This implies that the declaration creates an object. That is why the default constructor is called.

Originally Posted by derder

I initially asked if objects are created in my declaraton:

Code:

DCManager dcManger;

You said no. However reading your quote above, it seems you need to add a default constructor. This implies that the declaration creates an object. That is why the default constructor is called.

Context is important. Laserlight told you that when you do this:

Code:

class someClass {
    object_type myObj;
};

myObj is not constructed until you create an object of type someClass. This is a completely different context of code to

Code:

DCManager dcManager;

which is, well, the creation of a DCManager object. And in fact, it is at this time that myObj (and all the other bits'n'pieces of a DCManager) get created.

That's say at the main.cpp, I declare the myObj globally as follows:

Code:

object_type myObj;

Then at the main routine I have the following code and later passed to myFunctionReference and myFunctionArgument:

Code:

myObj = new object_type();

Question 1. How many times is myObj created? If twice, what happens during the new construction? Is it copy-assignment?


Also if I have to functions called myFunctionReference and myFunctionArgument:

Code:

void myFunctionReference(object_type &arg1) {
  myObj=arg1;
}
void myFunctionArgument(object_type arg1) {
 myObj=arg1;
}

In myFunctionReference, how many copy-assignment took place? Once? Right when the myObj is assigned to arg1.
In myFunctionArgument, is there two times? arg1 is another copy of object_type and myObj=arg1 makes another copy?