c++ - name - std::array value initialization

Can a member struct be zero-init from the constructor initializer list without calling memset? (2)

Let's say I have the following structure declaration (simple struct with no constructor).

struct Foo
    int x;
    int y;
    int z;
    char szData[DATA_SIZE];

Now let's say this struct is a member of a C++ class as follows:

class CFoobar
     Foo _foo;

If I declare CFoobar's constructor as follows:

    printf("_foo = {%d, %d, %d}\n", _foo.x, _foo.y,_foo.z);
    for (int x = 0; x < 100; x++)
       printf("%d\n", _foo.szData[x]);

As you would expect, when CFoobar's constructor runs, garbage data gets printed out Obviously, the easy fix is to memset or ZeroMemory &_foo. It's what I've always done...

However, I did notice that if add _foo to the constructor's initialization list with no parameters as follows:

: _foo()

That this appears to zero-out the member variables of _foo. At least that was the case with g++ on linux.

Now here's my question: Is this standard C++, or is this compiler specific behavior?

If it's standard behavior, can someone quote me a reference from an official source? Any "gotchas" in regards to implicit zero-init behavior with more complicated structs and classes?

It's the equivalent of float foo = float();

It will zero the object, even if the value representation is not all-bits-zero. I.e. it's even better than memset().

Yes, this is defined behaviour according to the standard. 12.6.2 [class.base.init] / 3 : "if the expression-list of the mem-initializer is omitted, the base class or member subobject is value-initialized."

Be warned, though, if Foo wasn't a POD-type but still had no user-declared constructor (e.g. it had a std::string type) then some very popular compilers would not correctly value-initialize it.

All compilers that I know of do correctly perform value-initialization of POD members when you use () as the initializer in a constructor initializer-list.