How Does Virtual Destructor work in C++

Question

I will type an example :

class A
{
public:
virtual ~A(){}
};

class B: public A
{
public:
~B()
{
}

};



int main(void)
{
A * a =  new B;
delete a;
return 0;
}

Now in Above Example , destructors will be called recursively bottom to up . My Question is how Compiler do this MAGIC .

Answer 1

A suitable implementation of (virtual) destructors the compiler might use would be (in pseudocode)

class Base {
...
  virtual void __destruct(bool should_delete);
...
};

void Base::__destruct(bool should_delete)
{
  this->__vptr = &Base::vtable; // Base is now the most derived subobject

  ... your destructor code ...

  members::__destruct(false); // if any, in the reverse order of declaration
  base_classes::__destruct(false); // if any
  if(should_delete)
    operator delete(this);  // this would call operator delete defined here, or inherited
}

This function gets defined even if you didn't define a destructor. Your code would just be empty in that case.

Now all derived classes would override (automatically) this virtual function:

class Der : public Base {
...
  virtual void __destruct(bool should_delete);
...
};

void Der::__destruct(bool should_delete)
{
  this->__vptr = &Der::vtable;

  ... your destructor code ...

  members::__destruct(false);
  Base::__destruct(false);
  if(should_delete)
    operator delete(this);
}

A call delete x, where x is of pointer to class type, would be translated as

x->__destruct(true);

and any other destructor call (implicit due to variable going out of scope, explicit x.~T()) would be

x.__destruct(false);

This results in

• the most derived destructor always being called (for virtual destructors)
• operator delete from the most derived object being called
• all members' and base classes' destructors being called.

HTH. This should be understandable if you understand virtual functions.