Re: Can an object know it is dead?

From:

"Daniel T." <daniel_t@earthlink.net>

Newsgroups:

comp.lang.c++

Date:

Fri, 23 Feb 2007 16:16:45 GMT

Message-ID:

<daniel_t-54A55D.11164423022007@news.west.earthlink.net>

"better_cs_now@yahoo.com" <better_cs_now@yahoo.com> wrote:

Hello all,

I suspect that a threading issue is leading to an object being
destructed in one thread context while one of its member functions is
still running in another thread context. As a means of confirming
this, I would like to have the object check if it is alive in the
referenced member function and report to me if it is not. However, I
cannot think of a standards-compliant way for an object to know that
it has been destructed.

Can anybody confirm that this *cannot* be done? If it cannot, can
anybody suggest any alternatives?

It cannot be done portably. However you might try putting in a "dead"
flag that is set to true in the destructor, then in all the
member-functions assert( dead == false ) might work.

An alternative that is standards conforming is to set-up a locking
mechanism. A simple map<void*, size_t> will work. Whenever an object
needs another (or itself) to stay alive, it increments the value in the
map associated with that object. In the destructor, the object can check
to make sure that its reference is zero. Something like this:

map<void*, size_t> lock;

class Object {
   ~Object() {
      assert( lock[this] == 0 );
   }

   void func() {
      ++lock[this];
      // do work
      --lock[this];
   }
};

void user( Object* o ) {
   ++lock[o];
   // work with 'o'
   --lock[o];
}

Of course it is wise to wrap the increment and decrement in an object
(RAII)

class Locker {
   const void* obj;
   Locker( const void* obj ): obj(obj) {
      ++lock[obj];
   }
   ~Locker() {
      --lock[obj];
   }
};