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?

[Edit] Seems to work on GCC as well.

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

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

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.