Accessing uninitialized atomic private variable in c++

Question

Supposed I have the following class:

class A
{
public:
...
...
void incrementN() {++n_;}
uint64_t getN() {return n_;}

private:
std::atomic<uint64_t> n_;
...
...

};

Assume that I initialize all the other variables in the class, except n_ and that this is not thread local storage, so there is no zero initialization.

I create an object of class A, and keep calling incrementN().

If at some point I want the value of n_, and I call getN(), can this cause the load() routine for the atomic n_ to crash?

Answer 1

The load uses memory_order_seq_cst by default. See here: http://en.cppreference.com/w/cpp/atomic/memory_order.

As mentioned in the comments, it shouldn't give you any problems that normal ints won't give. Are you concerned about overflow if the uninitialised initial value is large? See here for possible consequences: https://www.owasp.org/index.php/Integer_overflow

Answer 2

The n_ member variable is just uninitialized. The accessing of the field will cause a read in memory and there is no reason to crash, although the layout of that 8 bytes of memory is not known.

The fact that the member is atomic has no importance here. It will cause the compiler not to use any optimization on this specific variable and may also cause a cache line eviction to RAM on every write.