Question

Does anyone know any trick I could use to keep the Derived class until the base class destructor have been called?

i.e:

#include <iostream.h>
class Base
{
       public:
          Base(){ cout<<"Constructor: Base"<<endl;}
          virtual ~Base(){ cout<<"Destructor : Base"<<endl;}
};
class Derived: public Base
{
     //Doing a lot of jobs by extending the functionality
       public:
           Derived(){ cout<<"Constructor: Derived"<<endl;}
           ~Derived(){ cout<<"Destructor : Derived"<<endl;}
};
void main()
{
        Base *Var = new Derived();
        delete Var;
}

This will result in Derived class to be destroyed, then Base class will be destroyed.

The reason I need something like this is I have a custom Event(signal/slot) class.

The Event class provide an Observer class.

If I define :

class A : public Event::Observer

and then delete an instance of class A, when the ~Observer automatically remove any signal connected to this observer.

But since Class A is destroyed before the Observer, if something on a different thread call a slot on A after ~A and before ~Observer get called. Everything goes to hell…

I can always call the Observer.release method from the ~A, which fix the timing issue. But it was cleaner if I wouldnt need to.

Any ideas?

Answer 1

You definitely don’t want to change destruction order, which is good, because you can’t.

What you really want to do is to dispose/disconnect/shutdown the Observer.

What I would do is add this to your Event::Observer class:

void Event::Observer::Shutdown()
{
    if(!isShutdown)
    {
        //Shut down any links to this observer
        isShutdown = true;
    }
}

void ~Event::Observer()
{
    Shutdown();
    //rest of Event::Observer destruction
}

and then:

~A()
{
    Shutdown();
    //clean up any other A resources
}

If you did something like IDisposable suggested by David, that would work too — just call Observer::Dispose() in your destructor for class A.

My code all assumes that you have only a single thread accessing these objects. Thread synchronization is an entirely separate subject.