Is there a way in c++11 to prevent "normal" operations from sliping before or after atomic operation

I'm interested in doing something like(single thread update, multiple threads read banneedURLs):

atomic<bannedURLList*> bannedURLs;//global variable pointing to the currently used instance of struct
void  updateList()
{
       //no need for mutex because only 1 thread updates
       bannedURLList* newList= new bannedURLList();
       bannedURLList* oldList=bannedURLs;
       new开发者_如何学CList->initialize();
       bannedURLs=newList;// line must be after previous line, because list must be initialized before it is ready to be used

      //while refcnt on the oldList >0 wait, then delete oldList;
}

reader threads do something like this:

{
   bannedURLs->refCnt++;
   //use bannedURLs
   bannedURLs->refCnt--;
}

struct memeber refCnt is also atomic integer My question is how to prevent reordering of this 2 lines:

newList->initialize();
bannedURLs=newList;

Can it be done in std:: way?

Use bannedURLs.store(newList); instead of bannedURLs=newList;. Since you didn't pass a weak ordering specifier, this forces full ordering in the store.