Virtual destructors

[Christian Christmann]

Hi,

should destructors of a base class be always declared as "virtual"
in order to avoid "partially destroying"objects when a derived class
object is deleted through a pointer to a base class?

Or are there any cases where the base class destructor should
remain "non-virtual"?

Thank you.
Chris

 

[Rolf Magnus]

Hi,

should destructors of a base class be always declared as "virtual"
in order to avoid "partially destroying"objects when a derived class
object is deleted through a pointer to a base class?

Or are there any cases where the base class destructor should
remain "non-virtual"?

if there is no chance the object will get destroyed polymorphically, there
is basically no need for a virtual destructor. Otherwise, you must have
one.

 

[Ron Natalie]

if there is no chance the object will get destroyed polymorphically, there
is basically no need for a virtual destructor. Otherwise, you must have
one.

Correct, and a virtual destructor doesn't cost anything really except
in the case when there are NO other virtual functions (i.e., the class
isn't otherwise polymorphic). A good rule of thumb, is if you have
any virtual functions, make the destructor also virtual.

 

[Joe Van Dyk]

Christian Christmann wrote:




if there is no chance the object will get destroyed polymorphically, there
is basically no need for a virtual destructor. Otherwise, you must have
one.

If there's no chance for polymorphic destruction, then would you want
the destructor private?

Joe

 

[Ian Collins]

If there's no chance for polymorphic destruction, then would you want
the destructor private?

No, that would prevent you from instantiating the object. Both
constructor and destructor have to be public, unless you are building a
singleton.

 

[Ron Natalie]

If there's no chance for polymorphic destruction, then would you want
the destructor private?

Then you couldn't destroy it externally. For example:

class X {
~X(); // private desturctor
};

int main() {
X x;
}
wouldn't even compile.

 

[Ron Natalie]

No, that would prevent you from instantiating the object. Both
constructor and destructor have to be public, unless you are building a
singleton.

Well you could instantiate it, but you could "deinstantiate" it trhough
any method that couldn't see the destructor.

class X {
~X(); // private dstructor
public:
void DeleteMe() { delete this; }
};

int main() {
X x; // ill-formed
X* xp = new X; // OK
delete xp; // ill-formed
xp->DeleteMe(); // OK
}

 

[roods]

if there is no chance the object will get destroyed polymorphically, there
is basically no need for a virtual destructor. Otherwise, you must have
one.

The only time I could see when that is possible is if the class isn't a
base class. Otherwise, assumptions about your clients seem like a bad
idea. It may not be that you are treating objects polymorphically it
may just be you are creating an abstract class in which case a virtual
dtor is also a good idea.