Virtual functions but non-virtual destructor

This is from code I downloaded.

It has several classes with virtual functions but no virtual destructors. When I compile it, it does compile, but it gives a pageful of warning messages about "X has virtual functions but non-virtual destructor."

I guess the solution would be to add virtual destructors to each of those classes.

But why is the compiler griping about there being no virtual destructors? Isn't garbage clean up for classes supposed to be automatic in C++?

Without a virtual destructor, the code;

Code:

    BaseClass *x = new DerivedClass;   // DerivedClass is derived from BaseClass
    delete x;                                            //   undefined behaviour here

yields undefined behaviour. The existance of virtual member functions in the base class implies that there may be a derived class, and the above is a pretty common usage pattern in practice. Net result is that, if a class has any virtual member functions, it is usually a good idea for it to also have a virtual destructor.

Garbage cleanup is not automatic when you do dynamic memory allocation: it is necessary to explicitly (and correctly) release dynamically allocated objects.

It is a warning, not an error? So you can't say it doesn't compile...

If BaseClass doesn't have a virtual destructor (in the above case) it means, that if you delete x, the destructor will be called only for BaseClass, but not for DerivedClass. You give delete a BaseClass pointer and this and only this object is going to be cleaned up.

I'm not sure if there is anything undefined about that, but it surely can lead to problems. For example, if DerivedClass allocates some resources and expects to clean them up in the destructor, this simply won't happen, leading to a memory leak.

>> I'm not sure if there is anything undefined about that
Technically speaking it is undefined behavior (according to the standard) when you delete a base class pointer that points to a derived class and the base class destructor is not virtual. In practice, it often means that the derived class destructor is not called, but assuming that's the only issue isn't portable or wise.

Makes sense. Thanks guys.