Why should I use a virtual destructor in C++?

Using a virtual destructor in a base class is important when dealing with polymorphism and inheritance. When you have a pointer or reference to a base class, but the actual object is an instance of a derived class, a virtual destructor ensures that the correct destructor is called during object destruction.

Consider the following example:

1#include <iostream>
2
3class Monster {
4public:
5  ~Monster() { // Not Virtual 
6    std::cout << "Monster destroyed\n"; }
7};
8
9class Dragon : public Monster {
10public:
11  ~Dragon() {
12    std::cout << "Dragon destroyed\n"; }
13};
14
15int main() {
16  Monster* ptr = new Dragon();
17  delete ptr;
18}

1Monster destroyed

In this case, only the base class destructor is called, even though the actual object is a Dragon. This can lead to resource leaks or undefined behavior if the derived class has its own cleanup logic.

By making the base class destructor virtual, the correct destructor will be called:

1#include <iostream>
2
3class Monster {
4public:
5  virtual ~Monster() { // Virtual 
6    std::cout << "Monster destroyed\n"; }
7};
8
9class Dragon : public Monster {
10public:
11  ~Dragon() {
12    std::cout << "Dragon destroyed\n"; }
13};
14
15int main() {
16  Monster* ptr = new Dragon();
17  delete ptr;
18}

1Dragon destroyed
2Monster destroyed

Now, both the Dragon and Monster destructors are called in the correct order.

Remember, if a class has at least one virtual function, it's a good practice to make the destructor virtual as well. This ensures proper cleanup and prevents potential memory leaks when dealing with polymorphic objects.