C++ Struct inheritance against class inheritance

When a class derives from a class,
You can use a pointer to the parent class to delete the instance of
child
only when a virtual destructor declared in the parent.

class Parent
{
virtual ~Parent(); // virtual destructor
}

class Child : public Parent
{
}

Parent * instance = new Child();
delete instance;

===============================================

But is it the same when parent is a struct?

struct StructParent {
}

class Child : public StructParent {
}

StructParent * instance = new Child();
delete instance;

Does this mean that I should decleare a virtual destructor in
StructParent
to provide correct information about the parent and a safe delete
operation?
Or I can only write codes like:
Child * instance = new Child();
delete instance;

I'm a little confused.

Can I say that,
if I ensure that I only use pointer to the Child (bug not the
Parent's) and
perform delete operation on it, plus there is no virtual method in
both Parent and Child,
I can define no virtual destructor in struct inheritance and class
inheritance.

Thank you.

re: C++ Struct inheritance against class inheritance

johnsonlau wrote:
Yes, it is the same.
This is undefined behavior as you suspected.

That is one way.

That is fine, too.

Huh? Of course you can define a virtual destructor. However, in the case you
described, you don't have to.

What you need to keep in mind is that a virtual destructor is needed
whenever you delete an object of derived type through a pointer to a base.
It does not matter whether the type its a struct or a class nor whether it
has other virtual methods or not.

BTW: structs and classes in C++ only differ with regard to the default
access; structs are public by default and classes have private access by
default.


Best

Kai-Uwe Bux