Re: is std::list<obj>.push_back suppose to do a deep copy?

From:

red floyd <redfloyd@gmail.com>

Newsgroups:

comp.lang.c++

Date:

Tue, 23 Jun 2009 13:09:03 -0700 (PDT)

Message-ID:

<d3dcb7b2-8641-47cc-a183-5bd31f58ac76@l5g2000vbp.googlegroups.com>

On Jun 23, 12:54 pm, SpreadTooThin <bjobrie...@gmail.com> wrote:

On Jun 23, 1:44 pm, mzdude <jsa...@cox.net> wrote:

On Jun 23, 3:29 pm, SpreadTooThin <bjobrie...@gmail.com> wrote:> if I=

build a list of objects does push_back end up making a copy of

the object itself?

I have a problem.. when the list is destroyed...
as an example of what my code does....

What is the problem?

std::list<myObject> myListOfObjects;
myObject obj;

for i=0; i < n; ++i
{
obj.modifySomeProperty;
myList.push_back(obj);

}

When the function returns the list is destroyed by going out of
scope.. and of course so is obj.

What function?

First off ... Maybe I should have created a new instance of myObject
on each iteration of the loop or perhaps using the same one over and
over again is OK.... (as long as push_back is making a copy of the
object.)

Suggestions?

Yes. Ask what you want to know?

void MyFunc()
{
   std::list<MyObject> myList;
   MyObject myObject;
   for(int i=0; i < 10; ++i) {
      myObject.modify();
      myList.push_back(myObject); // Makes a copy
   }

   // do some stuff with my list

} // dtor of myObject, myList (an all objects in myList)

If the question is how many MyObjects exist at the end of the
function,
the answer would be 11. The one on the stack and the 10 in the list.
And yes all 11 dtors would be called.

That is helpful.

If the question is, are there memory leaks? Insufficient info. Need to
know much more about MyObject. What does it contain? Does it need a
copy constructor? Is one defined?

The class defines operator=, a copy constructor and a destructor.

but the program crashes during the destruction of the second object..
wierd...

Are you shallow-copying dynamically allocated pointers?

e.g (minimal example):

class X {
   T *p;
public:
   X(const X& x) p(x.p) { }
   X& operator=(const X& x)
       { p = x.p; }
   ~X() { delete p; }
};