Is pointer dereferencing atomic?

Question

Lets say I have a pointer to an integer.

volatile int* commonPointer = new int();

And I have multiple threads that dereference that pointer.

int blah = *commonPointer;

But, one thread needs to change that pointer's address:

int* temp = new int();
int* old = commonPointer;
InterlockedExchange(&commonPointer,temp);
delete old;

Now, lets ignore the fact that some threads may be reading the "old" value, and some may be reading the "new" value, that's not an issue in my case.

Can there be a scenario where one thread starts to dereference the pointer, just as the address is deleted, and then gets an exception ?
Or is the dereferencing atomic enough so that won't happen ?

Answer 1

Nothing in the C++ standard guarantees atomicity in this case.

You must protect the relevant code areas with a mutex: even std::atomic is not enough since it would only provide atomic access to the pointer but that would not include the dereference operation.

Answer 2

Perhaps, C++11

atomic<shared_ptr<int> > 

fit your needs. It prevents old value from disappearing until at least one reference to the value is valid.

atomic<shared_ptr<int> >  commonPointer;

// producer:
{
    shared_ptr<int> temp(new int);
    shared_ptr<int> old= atomic_exchange(&commonPointer, temp); 
    //...
};// destructor of "old" decrements reference counter for the old value


// reader:
{
    shared_ptr<int> current= atomic_load(&commonPointer);

    // the referent pointed by current will not be deleted 
    // until   current is alive (not destructed);
}

However, lock free implementation of atomic shared ptr is complicated enough so probably locks or spin locks will be used inside the library implementation (even if the implementation is available on your platform).