Is there a way to get a C++ class to automatically execute a method just before it starts executing the destructor?

Question

Here's a problem scenario: I've got a C++ object that includes a Cleanup() virtual method that needs to be called just before the object is destroyed. In order to do the right thing, this Cleanup method needs access to the fully-formed object (including subclass data), so I can't just call Cleanup() at the start of my own class's destructor, because by the time my class's destructor is called, the destructors any subclasses have already completed and they may have already freed some data that Cleanup() needed to look at.

The obvious solution would be to require the calling code to manually call my routine before deleting the object:

theObject->Cleanup();
delete theObject;

but that solution is fragile, since sooner or later somebody (probably me) will forget to call Cleanup() and bad things will happen.

Another solution would be to have a "holder" object that implements the pImpl technique to wrap the class, and have the holder object's destructor call Cleanup() on the object before deleting the object; but that solution isn't 100% desirable either, since it makes the class work differently from a standard C++ class and makes it impossible to allocate the object on the stack or statically.

So the question is, is there some clever technique (either in C++ or C++11) that I could use to tell the compiler to automatically call a specified (presumably virtual) method on my object before it calls the first subclass-destructor?

(come to think of it, a similar mechanism for automatically calling an Init() method -- just after the last subclass-constructor completes -- might be handy as well)

Answer 1

Lateral thinking: get rid of the Cleanup method, that's what a virtual destructor is for.

The very goal of a virtual destructor is to allow the outmost derived class destructor to be called when delete basepointer; is executed; and as RAII demonstrated, cleanup is the destructor's job.

Now you might argue that you would like an early Cleanup method, to ease the task of the destructor or maybe to reuse the object (kinda like a Reset method in a way). In practice, it rapidly turns into a maintenance nightmare (too easy to forget to clean one field and have state leak from one use to another).

So ask yourself the question: Why not use the destructor for what it's been created for ?

Answer 2

You can use a twist on the PIMPL wrapper:

class PIMPL
{
    MyDataThatNeedsInitDestroy    object;

  public:
    PIMPL(Atgs a)
       : object(a)
    {
        object.postCreationInit();
    }

    ~PIMP()
    {
        object.preDestructionDestory();
    }

    // All other methods are available via -> operator
    MyDataThatNeedsInitDestroy* operator->() { return &object);
};

Answer 3

Yes, this can be done with virtual inheritance, because virtual base subobjects are always constructed (and destroyed) by the most-derived type, and the order of construction (and destruction) of base classes is well-defined also.

Of course, you also may make the delete operator private, and provide a Release() member function consisting of Cleanup(); delete this; But that wouldn't help with stack-allocated objects.

Answer 4

struct B
{
    void cleanup()
    {
        if (!m_bCleanedUp)
        {
            m_bCleanedUp = true;
            ...
        }
    }

    virtual B::~B()
    {
        assert(m_bCleanedUp);
        ...
    }

    bool m_bCleanedUp = false;
};

struct D : B
{
    D::~D()
    {
        cleanup(); // if D author forgets, assert will fire
        ...
    }
};

Answer 5

Is there a way to get a C++ class to automatically execute a method just before it starts executing the destructor?

You need to use smart pointer (shared_ptr - available in boost or c++11) with custom deleter instead of raw pointers.

typedef shared_ptr<MyClass> MyClassPtr;
class MyClassDeleter{
public:
    void operator()(MyClass* p) const{
        if (p)
            p->cleanup();
        delete p;
    }
};

...

MyClassPtr ptr(new MyClass, MyClassDeleter());

--EDIT--

This will work for dynamically allocated objects. There is no solution (I can think of) for stack-allocated objects, so the reasonable action would be to make constructors private and make friend factory method that returns shared_ptr to constructed object - assuming you really need this mechanism.