Virtual destructor: is it required when not dynamically allocated memory?
The issue is not whether your classes allocate memory dynamically. It is if a user of the classes allocates a B object via an A pointer and then deletes it:
A * a = new B;
delete a;
In this case, if there is no virtual destructor for A, the C++ Standard says that your program exhibits undefined behaviour. This is not a good thing.
This behaviour is specified in section 5.3.5/3 of the Standard (here referring to delete
):
if the static type of the operand is
different from its dynamic type, the
static type shall be a base class of
the operand’s dynamic type and the
static type shall have a virtual
destructor or the behavior is
undefined.
When to use virtual destructors?
Virtual destructors are useful when you might potentially delete an instance of a derived class through a pointer to base class:
class Base
{
// some virtual methods
};
class Derived : public Base
{
~Derived()
{
// Do some important cleanup
}
};
Here, you'll notice that I didn't declare Base's destructor to be virtual
. Now, let's have a look at the following snippet:
Base *b = new Derived();
// use b
delete b; // Here's the problem!
Since Base's destructor is not virtual
and b
is a Base*
pointing to a Derived
object, delete b
has undefined behaviour:
[In
delete b
], if the static type of the
object to be deleted is different from its dynamic type, the static
type shall be a base class of the dynamic type of the object to be
deleted and the static type shall have a virtual destructor or the
behavior is undefined.
In most implementations, the call to the destructor will be resolved like any non-virtual code, meaning that the destructor of the base class will be called but not the one of the derived class, resulting in a resources leak.
To sum up, always make base classes' destructors virtual
when they're meant to be manipulated polymorphically.
If you want to prevent the deletion of an instance through a base class pointer, you can make the base class destructor protected and nonvirtual; by doing so, the compiler won't let you call delete
on a base class pointer.
You can learn more about virtuality and virtual base class destructor in this article from Herb Sutter.
When should you not use virtual destructors?
There is no need to use a virtual destructor when any of the below is true:
- No intention to derive classes from it
- No instantiation on the heap
- No intention to store with access via a pointer to a superclass
No specific reason to avoid it unless you are really so pressed for memory.
Calling destructor to free dynamically allocated memory
The memory was not freed. The destructor destroys the object but does not free the memory. How could it? You can destroy objects that are dynamically allocated, are on the stack, are globals, and so on. The destructor has no idea what is needed, if anything, to release the memory.
Related Topics
C++ Const Keyword - Use Liberally
C++ Specialization of Template Function Inside Template Class
What Is Wrong with Making a Unit Test a Friend of the Class It Is Testing
What Data Structure, Exactly, Are Deques in C++
C++11 Scope Exit Guard, a Good Idea
Ensuring C++ Doubles Are 64 Bits
Convert a Number to a String Literal with Constexpr
Qt 4.X: How to Implement Drag-And-Drop Onto the Desktop or into a Folder
Getting Std::Thread/Mutex to Work Under Win7 with Mingw and G++ 4.7.2
C++ Cannot Convert from Base a to Derived Type B via Virtual Base A
How to Include Correctly -Wl,-Rpath,$Origin Linker Argument in a Makefile
Fatal Error C1010 - "Stdafx.H" in Visual Studio How Can This Be Corrected
Cross-Platform Equivalent to Windows Events