How to properly delete pointers when using abstract classes

Question

Suppose I have the following classes and objects:

#include <iostream>

class Animal
{
public:
    virtual void makeNoise() = 0;

    void eat()
    {
        std::cout << "Eating..." << "\n";
    }

    void sleep()
    {
        std::cout << "Sleeping..." << "\n";
    }
};

class Cat: public Animal
{
public:
    void makeNoise()
    {
        std::cout << "Miow..." << "\n";
    }
};

class Cow: public Animal
{
public:
    void makeNoise()
    {
        std::cout << "Mooo..." << "\n";
    }
};

int main()
{
    Animal *animal;
    Cat *cat = new Cat();
    Cow *cow = new Cow();

    animal = cat;
    animal->eat();
    animal->sleep();
    animal->makeNoise();

    animal = cow;
    animal->eat();
    animal->sleep();
    animal->makeNoise();

    return 0;
}

Note that animal is an abstract class.

How can I properly delete the pointers animal, cat and cow?

When I try to delete animal; I get the following warning message:

warning: deleting object of abstract class type 'Animal' which has non-virtual destructor will cause undefined behaviour.

In the other hand, when I try to delete cat; I get the following message:

warning: deleting object of polymorphic class type 'Cat' which has non-virtual destructor might cause undefined behaviour.

Answer 1

A basic C++ rule says that destructors work their way up from the derived class to the base class. When a Cat is destroyed, then the Cat part is destroyed first and the Animal part is destroyed after.

delete animal; is undefined behaviour because in order to properly follow C++ destruction rules, one must know, at runtime, which derived class part should be destroyed before the Animal base part. A virtual destructor does exactly that - it enables a dynamic dispatch mechanism that makes sure destruction works as designed.

You have no virtual destructor, however, so delete animal just doesn't make sense. There is no way to call the correct derived-class destructor, and destroying only the Animal part wouldn't exactly be meaningful behaviour, either.

Therefore, the C++ language makes no assumptions about what will happen in such a situation.

Your compiler is nice enough to warn you about this.

---

With delete cat, the situation is slightly different. The static type of the cat pointer is Cat*, not Animal*, so it is clear even without any dynamic dispatch mechanism which derived-class destructor to call first.

The compiler still warns you about this, but it does so with a different wording ("might cause" vs. "will cause"). I believe the reason is that Cat might itself be the base class for more derived classes, seeing as it is already part of a class hierarchy with virtual functions.

It apparently doesn't bother to execute a more complete code analysis to find out that delete cat is really harmless.

---

In order to fix this, make the Animal destructor virtual. While you're at it, replace your raw pointers with std::unique_ptr. You still have to follow the virtual destructor rule for classes like yours, but you no longer have to perform a manual delete.