Re: problems of storing dynamically created objects in a vector
Jess wrote in message...
On Jun 10, 3:43 pm, "BobR" wrote:
// > > A7(){ out<<"A7()"<<std::endl;}
A7() : MyVal(5){ out<<"A7()"<<std::endl;}
~A7(){ out<<"~A7()"<<std::endl;}
A7( A7 const &){ out<<"A7(const A7&)"<<std::endl;}
// A7& operator=( A7 const &aa){
// out<<"operator=( A7 const &)"<<std::endl;
MyVal = aa.MyVal;
// Thing = new MyThing; // not Thing = aa.Thing!!!
// in copy-Ctor too? Try it. don't forget to delete Thing.
int MyVal;
// MyThing *Thing; // = new MyThing;
};
Thanks! I've run the example on my computer and here's what I've got:
[snip same output I got on GCC(MinGW)]
Where does the first A() come from? I guess when the vector of three
A7 objects is constructed perhaps one A7 object is created first and
then copy constructor is called three times to copy the initial object
to the vector. Then the first ~A() means the initial A7 object is
destroyed? When is it destroyed?
( see Mr. Bailey's post )
I put the 'destructing' line in so you could see that the temporary (if one)
does not get destructed by going out of scope. The vectors constructor
handles it.
Now experiment; add a couple 'push_back' ops to see what happens:
{
std::vector<A7> svA7( 3 );
out<<"- push_back -"<<std::endl;
{ // an extra scope ....
A7 tmp;
svA7.push_back( tmp );
svA7.push_back( tmp );
out<<"- push_back done -"<<std::endl;
} // ....to cause 'tmp' to destruct
// you mignt think that because 'tmp' no longer exists, the
// 'svA7' objects were now invalid. Are they (hint: cout)?
// ( put an 'int MyVal;' in your class, and output that.)
out<<"- destructing -"<<std::endl;
}
Furthermore, does a vector always
create an initial object and then destroy with the vector finishes
with it?
The temporary 'A7' you see? It's not guaranteed (AFAIK), left to the
implementation.
When the vector goes out-of-scope, or is otherwise destructed, it calls the
destructors for all the objects it holds. If the vector holds pointers, it
destructs the pointers, but not what they point to ( that's your
responsibility, or the 'smart-pointers' if you use them (that's their strong
point).).
You'll notice in your class that I showed (but commented-out) the
'operator=()'. That *may* become important if you put something in your
class, like a pointer to an dynamically created ('new') object. If you
simply copy the pointer content to a next A7 object, you now have two
pointers to the same memory area. One A7 gets destroyed, which deletes the
dyn. object, and then leaves the copy holding a pointer to something that no
longer exists - UB! So, add something to your class, uncomment the
assignment operator, and do some experiments (vecA = vecB;, etc..). Do not
be afraid to experiment, learn from mistakes. Thimk! <G>
I think this is what Ian meant? Is there any way that the
compiler doesn't create a temporary object?
Did you see temps in the output of the second section (where 'new' was
used)?
(ok, bad example ('cause it's pointers). Implementation thing again.)
[ corrections always welcome ]
--
Bob R
POVrookie