How to correctly inherit from a base class whose destructor is not virtual?

Question

I want to inherit from class A, but A's destructor is not virtual and I cannot modify A's definition. How to avoid the following case?

struct A
{
    A()
        : a(new char[8])
    {}

    ~A()
    {
        delete[] a;
    }

    char* a;
}

struct B : A
{
    B()
        : A(), b(new char[8])
    {}

    ~B()
    {
        delete[] b;
    }

    char* b;
};

int main()
{
    A* p_a = new B;
    delete p_a; // How to avoid such a dangerous deletion?
}

Answer 1

If the base class doesn't have a virtual destructor and you can't modify the class definition, you're pretty much out of luck. As a general rule of thumb, you probably shouldn't use public inheritance with a base class that doesn't have a virtual destructor.

Maybe you can try using composition instead of inheritance? Place an instance of A in B, and provide public member functions that wrap calls to member functions of A.

Answer 2

You can use struct B : private A so that A is an inaccessible base of B.

Answer 3

Just make the A a data member instead of a base class.

---

By the way, the classes violate the rule of three, which is an invitation to disaster. What if an instance is copied. Better use standard library containers instead of explicit new and delete.