Is it necessary to have virtual destructor if the derived class only contains automatic variable members?

Question

struct base
{
    base(){}
    ~base() { cout << "base destructor" << endl; }
};

struct derived : public base
{
    derived() : base() { vec.resize(200000000); }
    ~derived() { cout << "derived destructor" << endl; }
    vector<int> vec;
};

int main()
{
    base* ptr = new derived();
    delete ptr;

    while (true)
    {

    }
}

The above code leaks due to delete operation not calling derived object's destructor. But...

struct base
{
    base() {}
    ~base() { cout << "base destructor" << endl; }
};

struct derived : public base
{
    derived() : base() {}
    ~derived() { cout << "derived destructor" << endl; }
    int arr[200000000];
};

int main()
{
    base* ptr = new derived();
    delete ptr;

    while (true)
    {

    }
}

In second case, the memory doesn't leak despite the base destructor is only being called. So I'm assuming it's safe to not have a base destructor if all my members are automatic variables? Doesn't 'arr' member in derived class never go out of scope when derived object's destructor is not being called? What's going on behind the scenes?

It is not about leak, it is about undefined behaviour. Leaks may be a consequence of UB, but the main problem is that is may do anything... — OznOg, May 25 '19 at 12:59
*So I'm assuming it's safe to not have a base destructor if all my members are automatic variables?* -- What happens to your "safe" derived class if it has a `std::string` as a member? Or what if the derived class has any type of member, where that member's destructor needs to do some type of "work", i.e. close a handle? — PaulMcKenzie, May 25 '19 at 13:34

score 3 · Answer 1 · answered May 25 '19 at 12:59

It is always necessary to have a virtual destructor in a base class if a derived object is ever deleted through a pointer to that base. Otherwise behaviour of the program is undefined. In any other case it is not necessary to have a virtual destructor. It is irrelevant what members the class has.

score 3 · Accepted Answer · answered May 25 '19 at 13:35

YES!

I see that you are thinking "practically", about what destructions might be missed. Consider that the destructor of your derived class is not just the destructor body you write — in this context you also need to consider member destruction, and your suggestion may fail to destroy the vector (because the routine non-virtually destroying your object won't even know that there is a derived part to consider). The vector has dynamically allocated contents which would be leaked.

However we don't even need to go that far. The behaviour of your program is undefined, period, end of story. The optimiser can make assumptions based on your code being valid. If it's not, you can and should expect strange sh!t to happen that may not fit with how your expectation of a computer should work. That's because C++ is an abstraction, compilation is complex, and you made a contract with the language.

**See also:** [Does the C++ standard allow for an uninitialized bool to crash a program?](https://stackoverflow.com/q/54120862/560648) — Lightness Races in Orbit, May 25 '19 at 13:58

score 1 · Answer 3 · answered May 25 '19 at 13:17

It's not necessary to have a memory leak and still invoke an UB. Memory leak is a kind of expected UB if your derived class isn't trivial. Example:

#include <iostream>

class  Field {
public:
    int *data;
    Field() : data(new int[100]) {} 
    ~Field() { delete[] data; std::cout << "Field is destroyed"; }
};

class Base {
    int c;
};

// Derived class, contains a non-trivial non-static member                 
class Core : public Base 
{
    Field A;
};

int main()
{
    Base *base = new Core;
    delete base;  // won't delete Field
}

he C++ Standard, [expr.delete], paragraph 3 states (2014 edition)

In the first alternative (delete object), 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 the second alternative (delete array) if the dynamic type of the object to be deleted differs from its static type, the behavior is undefined.

In reality , if base class is trivial, all fields are trivial and derived class contains no non-static or non-trivial members, one might argue, that those classes are equal, but I'm yet to find way how to prove that through standard.It's likely an IB instead of UB.

Is it necessary to have virtual destructor if the derived class only contains automatic variable members?

3 Answers3

YES!