Re: Copy C'tor - doubt
On Nov 19, 5:04 pm, AY <techreposit...@gmail.com> wrote:
int main()
{
AB* ab = new AB(7);
//AB* cd = new AB;
AB* cd(ab);
return 0;
}
My Qn is in the statement - AB* cd(ab);
Does object 'cd' uses the same memory as object 'ab' ?
You have some confusion between objects and pointers to objects. I
think you could use an introductory C++ book, but I will take a stab
at your question:
Ex 1. The following creates an AB object:
AB ab(7);
This object is considered a local variable and lives on the stack. We
refer to this object by it's name, ab. When ab leaves scope, it will
be destroyed and memory will automatically freed from the stack.
Ex 2. The following creates an AB object:
new AB(7);
This AB object lives in the heap. It will stay in memory until the
you explicitly delete it. In that line, I didn't actually create any
way to access the AB object that is created, so this exact usage you
probably won't ever want to do.
Ex 3. The following creates a pointer that could point to an AB
object:
AB* ab;
This pointer is considered a local variable (and thus lives on the
stack). For now it doesn't point to anything useful.
No object of type AB is actually created. So as it stands, you can't
do anything with this pointer (until we have it point at an actual AB
object).
Ex 4. The following line creates an AB object and a pointer that
points to that AB object:
AB* ab = new AB(7);
Here the AB object is created as in example 2. Like the AB object in
2, it lives in the heap and will live there until you explicitly
delete it. Unlike example 2, we have also created a pointer named ab
that points to the object. This pointer is a local variable (stack).
With this pointer, we can access the object. The pointer will
disappear when it goes out of scope. However the AB object that is
created isn't tied to the life of the pointer that points to it, so it
can continue to live even after the initial pointer that pointed to it
goes away.
Ex 5. The following creates an AB pointer and another pointer that is
a copy of the first pointer:
AB* ab;
AB* cd(ab);
Here you have the example 3 scenario with ab. We have also created
another pointer called cd which you have told to be a copy of ab
pointer. This is a copy of the pointer itself, not a copy of whatever
ab was pointing to. Thus ab and cd point to the same "thing". In
this case, that thing is nothing useful. To get something useful,
read on...
Is any memory allocated in the heap for 'cd' like 'ab' [ I do not
think, maybe I'm wrong ] ?
No memory is created on the heap for cd. Like my example 3, it is
just a local variable, and some small amount of memory will be
allocated for it on the stack.
What happens here exactly.
After your "AB* cd(ab);" code, you will have:
- An AB object on the heap
- A pointer that is a local variable (stack) called ab, which points
to the above mentioned AB object
- A pointer that is a local variable (stack) called cd, which points
to the above mentioned AB object
Note you are copying the pointer, not the actual AB object. Only one
AB object exists, with two way to access it. Your copy constructor is
never called. To invoke the copy constructor you could do something
like:
AB* ab = new AB(7);
AB* cd = new AB(ab);
Now we have:
- An AB object on the heap
- A pointer that is a local variable called ab, which points to the
above mentioned AB object
- A second AB object on the heap that is a copy of the first AB object
- A pointer that is a local variable called cd, which points to the
second AB object.
Now if you make changes to the first AB object by the ab pointer, you
will not see the changes made to the second AB object (pointed at by
cd) because they are two separate objects.
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]