C++ Creating an atomic function

Question

void foo ( Bar* bar , void(Bar::*qux)(void) )
{
    if ( bar )
    {
        bar->qux();
    }
}

The problem is:

1. bar can be deleted after the check by another thread.

2. I can not add a mutex member to Bar in order to lock it.

Thus I wonder, if I can tell the processor to run this function atomically, and how would I do so? I've spent way to much time on Google, but found no understandable manuals...

P.S. Debian, gcc , Boost NOT allowed, C++11 IS allowed.

Answer 1

You probably want to use a smart pointer with shared ownership semantics (e.g. shared_ptr, intrusive_ptr) to make sure the object stays alive as long as you refer to it.

Answer 2

You want to temporarily share ownership of the object, in order to prevent another thread from deleting it. This is a job for shared_ptr, using weak_ptr to allow deletion when we don't need to access it:

void foo ( std::weak_ptr<Bar> weak_bar , void(Bar::*qux)(void) ) 
{
    if (std::shared_ptr<Bar> bar = weak_bar.lock())
    {
        // We now share ownership of the object - it won't be deleted
        bar->qux();
    }

    // We have released ownership - it can now be deleted
}

Of course, you still need synchronisation if multiple threads need to access the object; this only solves the problem of deletion specified in the question.