Does deleting a container of pointers also delete the (contained) pointers?

[Xamalek]

Greetings,

I have a question. When using an STL container, does deleting a container of
pointers also call delete on the (contained) pointers?

For example, if I have (ignore the fluff, it is simply used to explain my
issue)

struct Proc
{
int uid;
int pid;
int parent_id;
};

and then I have

queue<Proc*> Q = new queue<Proc*>;

// I then populate the queue with Proc types


If I do a

delete Q;

will that destroy the queue and the inner elements as well, or do I have to
do the work of ensuring that delete is also called on all the Proc*'s
(contained by the queue) as well?

Sincerely,
X

 

[Rolf Magnus]

Greetings,

I have a question. When using an STL container, does deleting a
container of pointers also call delete on the (contained) pointers?
No.


For example, if I have (ignore the fluff, it is simply used to explain
my issue)

struct Proc
{
int uid;
int pid;
int parent_id;
};

and then I have

queue<Proc*> Q = new queue<Proc*>;

// I then populate the queue with Proc types


If I do a

delete Q;

will that destroy the queue and the inner elements as well, or do I
have to do the work of ensuring that delete is also called on all the
Proc*'s (contained by the queue) as well?

The latter.

 

[Cy Edmunds]

Greetings,

I have a question. When using an STL container, does deleting a container of
pointers also call delete on the (contained) pointers?

No. Imagine if it did:

void disaster()
{
std::vector<int*> v;
int k;
v.push_back(&k);
} // undefined behavior here if std::vector deleted contained pointers

There is no way for the collection to tell if the pointer was obtained from
the new() operator or not.

For example, if I have (ignore the fluff, it is simply used to explain my
issue)

struct Proc
{
int uid;
int pid;
int parent_id;
};

and then I have

queue<Proc*> Q = new queue<Proc*>;

Huh? I think you mean:

queue<Proc*> *Q = new queue<Proc*>;

although why you would dynamically allocate it is beyond me.

// I then populate the queue with Proc types


If I do a

delete Q;

will that destroy the queue and the inner elements as well, or do I have to
do the work of ensuring that delete is also called on all the Proc*'s
(contained by the queue) as well?

You have to delete them yourself unless you use a reference counted smart
pointer.

 

[Evan]

You have to delete them yourself unless you use a reference counted smart
pointer.

Most smart pointers should do really; I think the auto_ptr of the
standard library would work fine. For instance:
queue<std::auto_ptr<Proc> > *Q = new queue<std::auto_ptr<Proc> >;
...
delete Q;
should do the trick. You have to be careful with this though, make
sure you know what auto_ptr does before you use it, or you could
easily run into greater trouble than allowing memory leaks (which your
program does now by not deleting what the contents point to) by
accessing memory you think is good but is out of scope because the
auto_ptr went out of scope and deleted its subject.

Evan

 

[Karl Heinz Buchegger]

Most smart pointers should do really; I think the auto_ptr of the
standard library would work fine.

No. auto_ptr doesn't work. Its copy semantics are wrong.
But the smart pointers from the boost library will work fine.

www.boost.org

 

[Rob Williscroft]

Evan wrote in

Most smart pointers should do really; I think the auto_ptr of the
standard library would work fine. For instance:
queue<std::auto_ptr<Proc> > *Q = new queue<std::auto_ptr<Proc> >;
...

Unfortunatly you cant put std::auto_ptr<> into a standard container
as it doesn't meet the minimum requirments, for a containers value_type,
this because it moves rather than copies or assign's it contents.

look into boost shared_ptr if you want to do this:

http://www.boost.org/libs/smart_ptr/shared_ptr.htm

delete Q;
should do the trick. You have to be careful with this though, make
sure you know what auto_ptr does before you use it, or you could
easily run into greater trouble than allowing memory leaks (which your
program does now by not deleting what the contents point to) by
accessing memory you think is good but is out of scope because the
auto_ptr went out of scope and deleted its subject.

Rob.

 

[Gavin Deane]

Most smart pointers should do really; I think the auto_ptr of the
standard library would work fine. For instance:
queue<std::auto_ptr<Proc> > *Q = new queue<std::auto_ptr<Proc> >;
...
delete Q;

Don't do that. See http://www.gotw.ca/gotw/025.htm

hth
GJD

 

[Evan]

No. auto_ptr doesn't work. Its copy semantics are wrong.
But the smart pointers from the boost library will work fine.

www.boost.org

(In reply to Rob and Gavin too)

Doh, yes, I read about that. In a couple places. Including the GOTW
columns.

Yes, auto_ptr won't work because the containers copy around their
values internally. I forgot about that. Thanks guys.