Question

Given the following example:

class BaseClass
{
  BaseClass()
  {
  };

  virtual ~BaseClass()
  {
    this->Cleanup();
  };

  virtual void Cleanup()
  {
    // Do cleanup here.
  };
};

class Level1DerivedClass : public BaseClass
{
  Level1DerivedClass()
  {
  };

  virtual ~Level1DerivedClass()
  {
  };

  virtual void Cleanup()
  {
    // Call my base cleanup.
    BaseClass::Cleanup();

    // Do additional cleanup here.
  };
};

class Level2DerivedClass : public Level1DerivedClass
{
  Level2DerivedClass()
  {
  };

  ~Level2DerivedClass()
  {
  };

  void Cleanup()
  {
    // Call my base cleanup.
    Level1DerivedClass::Cleanup();

    // Do additional cleanup here.
  };  
};


main()
{
  Level2DerivedClass * derived2 = new Level2DerivedClass();
  delete derived2;
  return 0;
}

When I delete my derived class reference, I would EXPECT the flow would be as follows:

1. Level2DerivedClass destructor is executed.
2. Because Level1DerivedClass destructor is virtual, it would be executed.
3. Because BaseClass destructor is virtual, it would be executed.
4. Because BaseClass::Cleanup and Level1DerivedClass::Cleanup are both virtual, the call from the BaseClass ‘this’ pointer in the BaseClass destructor would executed the implementation of the most derived class – Level2DerivedClass::Cleanup.
5. Level2DerivedClass::Cleanup calls its parent’s Cleanup implementation.
6. Level1DerivedClass::Cleanup calls its parent’s Cleanup implementation.

What is happening is that it is calling the destructors for each level of inheritance (1 – 3) above the way I’m expecting. But when this->Cleanup() is called from the BaseClass destructor, it only executes its own implementation. I don’t understand why this is happening because normally when you instantiate a derived class pointer, cast it as a base class pointer, and call a virtual method from the base class pointer (in this case, ‘this’), it still runs the derived class implementation (the whole point of ‘virtual’, yes?). In my example, Level2DerivedClass::Cleanup and Level1DerivedClass::Cleanup never gets called.

The reason I’m setting it up this way is I want to be able to call my Cleanup code without having to destroy my object, which is why I’m abstracting it from the actual destructor body.

If you have suggestions on a more proper way to do this, I’m all ears. But I would also like an explanation of why my setup doesn’t work – what am I misunderstanding?

Thank you in advance for your time.

Answer 1

The rule of thumb is: Never Call Virtual Functions during Construction or Destruction.

They don’t behave as you might expect; as each destructor finishes, the dynamic type of this is effectively modified. From [class.cdtor] in the C++ standard:

When a virtual function is called directly or indirectly from a constructor (including the mem-initializer or
brace-or-equal-initializer for a non-static data member) or from a destructor, and the object to which the
call applies is the object under construction or destruction, the function called is the one defined in the
constructor or destructor’s own class or in one of its bases, but not a function overriding it in a class derived
from the constructor or destructor’s class, or overriding it in one of the other base classes of the most derived
object.