是否可以确保原子的0初始化将值成员设置为0？

Question

What does 0-initialization of std::atomic<integral_type> variable mean?

Origins of the question. I have a function-static std::array of std::atomic<std::int> , which I want to be set to 0 before the first use (goes without saying, function where the array resides is called in unpredictable manner from multiple threads).

This piece of code is good-looking, but not compiling due to atomics being non-copy constructable:

#include <array>
#include <atomic>

void foo() {
    using t = std::atomic<int>;
    static std::array<t, 2> arr = {0, 0}; // <-- explicit, but errors out (see below)
    static std::array<t, 2> arr2; // <-- implicit?, works
}

error: use of deleted function 'std::atomic::atomic(const std::atomic&)' std::array arr = {0, 0};

Now, I understand that static std::array is going to 0-initialize all it's members, and std::atomic<> is going to be 0-initialized. But do we have an explicit or implicit gurantee that it will actually set all values to 0? Common sense says 'yes' - after all, we assume the class would have a member of type int , and this member will be 0-initialized. But is that assumption based on solid grounds of standard?

Answer 1

Use (normally redundant) braces to avoid copy-initialization:

static t arr[2] = {{0}, {0}};
static std::array<t, 2> arr2 = {{{0}, {0}}}; /* Need extra pair here; otherwise {0} is
                                                treated as the initializer of the internal 
                                                array */

Demo . When omitting the braces, we're copy-initializing, which necessitates a temporary being created and copied from. With the braces, we have copy-list-initialization, which acts the same as direct-list-initialization (ie initializes each element with {0} , which is fine).

You can also wait until guaranteed copy elision is introduced and just use your syntax.

Answer 2

What you need to differentiate is default-initialization and zero-initialization. I have red about this very topic some time ago, and came to the conclusion that the standard implicitly requires the atomic-class to act identical to structs when it comes to initialization.

The non-atomic base type needs to be trivially copy-able, and the atomic type needs to both support default initialization and being initialized statically with (and without) ATOMIC_VAR_INIT . There aren't any any clean solutions I could come up with that don't end up using an inner struct or a deriving from a struct (I wrote an atomic implementation for a in-house RT OS).

So the standard if not requires, at least highly steers the implementation towards a solution where zero-initialization does exactly what you want.

I made a Live Example which compares the following:

std::array<t, 2> default;
std::array<t, 2> zero{};
std::array<t, 2> explicit{{{0},{0}}};

you will see that zero initialization is identical to the explicit version, and with gcc 6.3.0 even more efficient.

Just to reiterate, I don`t think the standard explicitly requires zero-initialization to behave that way, but - to my understanding - given what is defined it necessarily has to.

Answer 3

From cppreference, documentation of the default constructor of std::atomic says:

Constructs new atomic variable.

1) The default constructor is trivial: no initialization takes place other than zero initialization of static and thread-local objects. std::atomic_init may be used to complete initialization.

So you will need Columbo's initialisation loop for sure.