• FEATURED

View more

View more

View more

### Image of the Day Submit

IOTD | Top Screenshots

### The latest, straight to your Inbox.

Subscribe to GameDev.net Direct to receive the latest updates and exclusive content.

# Multiple inheritance and mix of virtual and non-virtual base class destructors

Old topic!

Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.

7 replies to this topic

### #1Prune  Members

Posted 20 February 2014 - 03:22 PM

I have a class inheriting from two other classes, where one of the base classes has a virtual destructor, and the other one, a non-virtual destructor. I'm using Visual C++ 2012. When deleting the object through a pointer of type of the first base class, the one with a virtual destructor, it still calls the destructor of the base class where it is not virtual. Is this standard behavior? I would have expected that only destructors of the base classes which are virtual will be called.

class A
{
public:
~A(void) { cout << "~A() "; }
};

class B
{
public:
virtual ~B(void) { cout << "~B() " << endl; }
};

class AB : public A, public B
{
};

B *p = new AB;
delete p;

// Output: ~B() ~A()


Can I rely on ~A() being called on all C++ compilers?

 Seems to work on GCC as well.

Edited by Prune, 20 February 2014 - 03:25 PM.

"But who prays for Satan? Who, in eighteen centuries, has had the common humanity to pray for the one sinner that needed it most?" --Mark Twain

~~~~~~~~~~~~~~~Looking for a high-performance, easy to use, and lightweight math library? http://www.cmldev.net/ (note: I'm not associated with that project; just a user)

### #2King Mir  Members

Posted 20 February 2014 - 03:27 PM

I can't quote the standard for you, but the result is consistent with what I'd expect. AB's destructor is being called, which in turn call it's super class destructors in reverse order. A's destructor is not being called through virtual dispatch, but because the function that the compiler builds for AB's destruction calls it.

### #3Prune  Members

Posted 20 February 2014 - 03:31 PM

So only the pointer through which an object is deleted needs a type with a virtual destructor, correct?

"But who prays for Satan? Who, in eighteen centuries, has had the common humanity to pray for the one sinner that needed it most?" --Mark Twain

~~~~~~~~~~~~~~~Looking for a high-performance, easy to use, and lightweight math library? http://www.cmldev.net/ (note: I'm not associated with that project; just a user)

### #4King Mir  Members

Posted 20 February 2014 - 03:43 PM

So only the pointer through which an object is deleted needs a type with a virtual destructor, correct?

Yes.

Which means that in principle, it is possible to have inheritance without needing a virtual destructor.

### #5frob  Moderators

Posted 20 February 2014 - 03:44 PM

I have a class inheriting from two other classes, where one of the base classes has a virtual destructor, and the other one, a non-virtual destructor.

Generally: Don't.

There are very few exceptions to the rule, but when a class does not have a virtual destructor you should not derive from it. It can be acceptable if you can provide guarantees that no code will EVER call a destructor on a derived object that uses a base type pointer, and that all non-virtual behavior in the base class, when that base class is used anywhere, will NEVER interfere with derived class designs. In your case I would probably go so far as to prohibit all dynamic allocation of the combined object. Even people who are language lawyers need to go back and double-check the code when you attempt to inherit with non-virtual destructors.

If people just follow the very good advice Herb Sutter (the guy who runs the c++ language committee) has frequently given, that all destructors should either be public and virtual or protected and non-virtual, then everyone would be a lot happier in life.

Just from your description and code sample, I'm pretty much certain that whatever you are proposing has a better solution. Most likely it involves composition.

edit: Following up, what you described is rarely done. The main reason for doing that type of thing is to mix with third-party libraries in extremely awkward situations that have no workaround. Beware, because the 3rd party library might have made assumptions about the function pointers because they one they gave you has a non-virtual destructor. Their code is likely going to be doing something that breaks or slices or otherwise damages the combined object. Inheritance is a very powerful link. Multiple inheritance of concrete classes is almost always the wrong design choice.

Edited by frob, 20 February 2014 - 03:54 PM.

Check out my book, Game Development with Unity, aimed at beginners who want to build fun games fast.

Also check out my personal website at bryanwagstaff.com, where I occasionally write about assorted stuff.

### #6SeanMiddleditch  Members

Posted 20 February 2014 - 11:47 PM

It helps if you understand how virtual tables and destructors work. Glossing over some finer details just to get the basics across:

1) Destructors are just methods.

2) When you invoke a virtual method, the "most derived" override for that method is invoked.

3) When you invoke the destructor of any class, the object is destructed and then all the bases are destructued.

If you invoke a virtual destructor on any type and since (1) it is a virtual method then (2) the "most derived" destructor is invoked which (3) recursively invokes every destructor of every type in the hierarchy (and for every member).

frob's advice about just not doing what you're doing is very good.  But it's nice to know why terrible things that still work do actually work.

edit: I originally intended to describe the actual mechanism by which this all works but the abstract description above is sufficient.

Edited by SeanMiddleditch, 20 February 2014 - 11:48 PM.

Game Developer, C++ Geek, Dragon Slayer - http://seanmiddleditch.com

C++ SG14 "Games & Low Latency" - Co-chair - public forums

Wargaming Seattle - Lead Server Engineer - We're hiring!

### #7tanzanite7  Members

Posted 21 February 2014 - 06:20 AM

... all destructors should either be public and virtual or protected and non-virtual ...

QFE.

Speaking of multiple inheritance: i have never used it nor found a legitimate use for it over a decade. Might be just me, so - has anyone here encountered (or even written) code with multiple inheritance and found it to be the best solution for whatever the problem case is (excluding code-base forced decisions ... in case that is the ONLY justification)?

Honest question.

### #8Bill Door  Members

Posted 21 February 2014 - 10:17 AM

Your example works because the deleted object is the type with the virtual destructor.  e.g.

B *p = new AB;

delete p;

However,

A *p = new AB;
delete p;

I would expect that this would not call the destructor for AB or B.

In the first example, the object is of type B, which has a virtual destructor, which causes the virtual table to be used which calls the destructor for AB, which in turn destroys, A and B.

As an object of type A, the compiler has no idea that it should do anything except call the destructor for A. There is no virtual table to access, so only the destructor for A is called.

Old topic!

Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.