Pointers, Vectors, and Destructors

[joevandyk]

Below, I have a class Container that contains a vector. The vector
contains pointers to a Base class. When the Container destructor is
called, I would like to delete all the objects that the pointers in the
vector are pointing to.

It works fine, IF I comment out the destructors in Base and Inherited.
If I leave the explicit destructors in there, it seg faults. Why is
there a difference?
Thanks,
Joe

#include <iostream>
#include <vector>

using namespace std;

struct Base {
virtual ~Base() {}
};

struct Inherited : public Base {
~Inherited() {}
};

class Container
{
public:
vector<Base*> v;

~Container()
{
// Need to delete pointed-to objects in v
for (vector<Base*>: :iterator i = v.begin();
i != v.end();
++i)
{
cout << "Deleting " << *i << endl;
delete *i;
}
}
};

int main()
{
Container c;

Inherited *f = new Inherited();

// Adding two pointers to the same object to Container
c.v.push_back(f );
c.v.push_back(f );

return 0;
}

[Victor Bazarov]

jo*******@gmail .com wrote:

Below, I have a class Container that contains a vector. The vector
contains pointers to a Base class. When the Container destructor is
called, I would like to delete all the objects that the pointers in the
vector are pointing to.

It works fine, IF I comment out the destructors in Base and Inherited.
If I leave the explicit destructors in there, it seg faults. Why is
there a difference?
None whatsoever. Your program produces undefined behaviour in both
cases. See below.


Thanks,
Joe

#include <iostream>
#include <vector>

using namespace std;

struct Base {
virtual ~Base() {}
};

struct Inherited : public Base {
~Inherited() {}
};

class Container
{
public:
vector<Base*> v;

~Container()
{
// Need to delete pointed-to objects in v
for (vector<Base*>: :iterator i = v.begin();
i != v.end();
++i)
{
cout << "Deleting " << *i << endl;
delete *i;
}
}
};

int main()
{
Container c;

Inherited *f = new Inherited();

// Adding two pointers to the same object to Container
c.v.push_back(f );
c.v.push_back(f );
How many pointers to the _same_ object does 'c.v' now contain? How
many times will you attempt to delete that object?

return 0;
}

V

[joevandyk]

Victor Bazarov wrote:

jo*******@gmail .com wrote:

Below, I have a class Container that contains a vector. The vector
contains pointers to a Base class. When the Container destructor is called, I would like to delete all the objects that the pointers in the vector are pointing to.

It works fine, IF I comment out the destructors in Base and Inherited. If I leave the explicit destructors in there, it seg faults. Why is there a difference?

None whatsoever. Your program produces undefined behaviour in both
cases. See below.

Thanks,
Joe

#include <iostream>
#include <vector>

using namespace std;

struct Base {
virtual ~Base() {}
};

struct Inherited : public Base {
~Inherited() {}
};

class Container
{
public:
vector<Base*> v;

~Container()
{
// Need to delete pointed-to objects in v
for (vector<Base*>: :iterator i = v.begin();
i != v.end();
++i)
{
cout << "Deleting " << *i << endl;
delete *i;
}
}
};

int main()
{
Container c;

Inherited *f = new Inherited();

// Adding two pointers to the same object to Container
c.v.push_back(f );
c.v.push_back(f );

How many pointers to the _same_ object does 'c.v' now contain? How
many times will you attempt to delete that object?

c.v has two pointers to the same object. I try to delete the object
twice.

I agree, bad thing, but was wondering why it seemed to work without
explicit destructors.

Is there a way to tell whether or not a pointed-to object has been
deleted?

return 0;
}

V

[Stephan Brönnimann]

You can actually avoid similar problems if you use std::auto_ptr
whenever the ownership
of a pointer changes.
And of course you'll need a copy constructor and assignment operator as
well
(or prevent them as shown below).

#include <memory>
class Container {
public:
// ...
void push_back(std:: auto_ptr<Base*> base) {
v.push_back(bas e.release(); }
private:
// prevent copying: not implemented:
Containter(cons t Container&);
// prevent assignment: not implemented:
Container& operator=(const Container&);
private:
vector<Base*> v;
};

Alternatively boost provides boost::shared_p tr.

Regards,
Stephan Brönnimann
br****@osb-systems.com
http://www.osb-systems.com
Open source rating and billing engine for
communication networks.

[PKH]

<jo*******@gmai l.com> wrote in message
news:11******** **************@ f14g2000cwb.goo glegroups.com.. .

Victor Bazarov wrote:

jo*******@gmail .com wrote:

<snip> Is there a way to tell whether or not a pointed-to object has been
deleted?

Do a search on Smartpointers. They are good for this kind of thing, by
doing reference counting, or by integrating smartpointers with the delete
operator.

PKH

[Lionel B]

Jonathan Mcdougall wrote:

jo*******@gmail .com wrote:

Below, I have a class Container that contains a vector.
The vector contains pointers to a Base class. When
the Container destructor is called, I would like to
delete all the objects that the pointers in the vector
are pointing to.

/.../
For your specific case, since you have a container of
pointers which you must delete, I would use a std::set,
which allows no duplicates. That will prevent such misusage.

Unless, of course, the OP wants/needs (for whatever reason) to allow
mutiple pointers to the same object. In which case some kind of
reference counting (smart pointer?) is probably the way to go.
--
Lionel B

[Duane]

<jo*******@gmai l.com> wrote in message news:11******** *************@z 14g2000cwz.goog legroups.com...

Below, I have a class Container that contains a vector. The vector
contains pointers to a Base class. When the Container destructor is
called, I would like to delete all the objects that the pointers in the
vector are pointing to.

It works fine, IF I comment out the destructors in Base and Inherited.
If I leave the explicit destructors in there, it seg faults. Why is
there a difference?

What if you call clear() on the vector after the delete and
before pushing back more pointers?

How about one of the boost smart pointers?

[Ron Natalie]

al******@hotmai l.com wrote:

Is there a way to tell whether or not a pointed-to object has been

deleted?

You could maintain a set of deleted pointers and use this to ensure
that you don't call delete with the same pointer twice.

That's also undefined behavior. You're not allowed to use the
value of a deleted pointer.