Zero initialization of nested struct - compiler bug?

Question

Consider this example:

#include <vector>
#include <stdexcept>

struct A
{
    float a;
    float b;
    float c;
    float d;
};

struct B
{
    A a;
    std::vector<int> b;
};
    

int main() {

    B b{};

    if (b.a.a || b.a.b || b.a.c || b.a.d) throw std::runtime_error("Compiler bug?");
}

If I understand correctly, according to https://en.cppreference.com/w/cpp/language/zero_initialization, it cannot throw because zero initialization should be performed for B::a as it should for "members of value-initialized class types that have no constructors".

If it throws, is it a compiler bug or am I missing something?

[edit]

Here with clang 10 and optimization enabled it just does "mov eax, 2" and "ret" (meaning the condition is false): https://godbolt.org/z/CXrc3G

But if I remove the braces, it does "mov eax, 1" and "ret" (meaning the condition is true). But here I think it can return whatever it want because it's just UB. https://godbolt.org/z/tBvLzZ

So it seems clang thinks that with braces zero initialization must be performed.

Edit: I submitted a bug on intel's website: https://community.intel.com/t5/Intel-C-Compiler/Aggregate-initialization-bug-with-nested-struct/td-p/1178228

An intel person replied "I've reported this issue to our Developer." Poor developer, single-handedly supporting all icc development.

Answer 1

Firstly: the objects b.a.a, b.a.b, b.a.c, b.a.d are guaranteed to be zero-initialized. Which for float is initialized as if by = 0; (not necessarily a representation of all bits zero).

B b{}; only translates to zero-initialization in some cases (the cppreference page is a bit misleading).

In C++14: Since B is an aggregate , this is aggregate initialization, each member is initialized as if by an empty list . So A a; gets initialized as if A a{};. The A is also an aggregate so each of its elements is initialized as if by an empty list, which for built-in types is zero-initialization.

In C++11 the wording was different (list initialization of an aggregate class from an empty list was not actually considered aggregate initialization) but the outcome was the same.

In C++03, B b{}; was a syntax error, but B b = {}; was allowed, and also turns out to zero-initialize the floats in question.

In C++98, the rules were different and to cut a long story short, B b = {}; would call the default constructor of A which leaves the values uninitialized. We like to pretend C++98 initialization never existed, but some compilers clung onto those rules even into the 2010s.

---

With that out of the way, there might be some argument about whether a zero-initialized float is guaranteed to act as false for the || operator, see Comparing floating point number to zero.

The standard says "A zero value, null pointer value, or null member pointer value is converted to false". Which isn't 100% precise but IMO the zero-initialized float should count as "a zero value" for this purpose.