Do shared pointers use atomic operations in reference counting even in a single threaded program

Question

To be multi-thread safe, the std::shared_ptr uses atomic operations to perform reference counting. While this is good, I have the following questions:

1. If the program is a single-threaded one, is there a compiler smart enough to use plain (non-atomic) increment and decrement operations instead?
2. Following the above question, if the answer is no, is there a way to tell the compiler that he program is single-threaded, so don't bother using atomic operations while compiling it?

Answer 1

1. It will depend on the compiler. Visual Studio 2017 is not smart enough. I cannot tell what clang will do (I am not using them on daily basis) but I will bet that their are not that smart either. As @yachoor pointed out in comment "g++ on Linux is smart enough - it doesn't use atomic operations for std::shared_ptr if program isn't linked with pthread"

2. Not sure but there is no standard way to do this. Take a look at this. You can use std::move operator so there reference will not be increased. If that is not the case I think that there is no easy way to do this.

Regarding point 2, there are other possibilities. You can extract the pointer to that object and pass it as reference everywhere it is needed in your program. As it is single threaded you should be pretty much sure about lifetime of this object. Otherwise you might want to rethink you memory ownership desing.