do I need a virtual destrucotr?

[Jimmy Johns]

Hi all, I have some class hierarchy as follows:

class S {};
class A {};
class B {public: vector<S*> v_; virtual ~B();};

class C : public virtual A, public virtual B { // do I need to define
virtual ~C() so that B can be properly destructed?};

in fact, I don't even know if a destructor in C is even needed if I don't do
any memory allocation? Thanks in advance.

jj.

 

[Jimmy Johns]

Okay, so for clarification purposes, suppose I have the following:
base (pure virtual)
^
|
|
poly derived1
^
|
|
derived2

and base, derived1, derived2 do not contain anything that needs to be
specially allocated, deallocated. Then I do something like:

base* p = new derived2;

then I do:
delete p;

then only base's destructor will be called... correct? But that's okay,
since stuff inside derived1 and derived2 (such as vector<>, list<>, etc)
should take care of themselves? Or is it necessary to define the destructor
explicitly, and call
vector<>.clear() for vectors, lists... etc? It seems extrememly tedious to
go throught the inheritance hierarchy and clearing objects that shouldn't
have to be cleared. Any suggestions? Maybe I'm just confusing myself.

jj

 

[Rolf Magnus]

Okay, so for clarification purposes, suppose I have the following:
base (pure virtual)

What is pure virtual? The destructor?

^
|
|
poly derived1
^
|
|
derived2

and base, derived1, derived2 do not contain anything that needs to be
specially allocated, deallocated. Then I do something like:

base* p = new derived2;

then I do:
delete p;

then only base's destructor will be called... correct?

If you mean above that base's destructor is virtual, then no. derived2's
destructor will be called. If OTOH, base's destructor is not virtual,
then you are correct.

But that's okay, since stuff inside derived1 and derived2 (such as
vector<>, list<>, etc) should take care of themselves?

What do you mean by "take care of themselves"? Their destructors must be
called by someone. If derived2's destructor is called, the destructors
of its member variables are called too.

Or is it necessary to define the destructor explicitly, and call
vector<>.clear() for vectors, lists... etc?

Their destructors will do that when (and if) they are destroyed
properly.

It seems extrememly tedious to go throught the inheritance hierarchy
and clearing objects that shouldn't have to be cleared. Any
suggestions? Maybe I'm just confusing myself.

I guess you are. It's actually rather simple: If there is a chance (even
if very low) that an instance of derived1 or derived2 is deleted
through a pointer to base, base's destructor must be virtual. Then the
correct destructor is automagically called.