GCC wrong `missing initializer for member <anonymous>` warning? - c++

Question

I'm trying to run the following code in my project:
#include <memory>
enum class Type
{
SpecificType
};
struct BaseData
{
using Ptr = std::unique_ptr<BaseData>;
BaseData(Type type) noexcept : type(type) {}
const Type type;
};
template <typename T, Type VType>
struct Data : BaseData
{
using Ptr = std::unique_ptr<T>;
Data() noexcept : BaseData(VType) {}
static Ptr make(T&& val) { return std::make_unique<T>(std::move(val)); }
};
struct SpecificData : Data<SpecificData, Type::SpecificType>
{
int field1;
int field2;
};
int main()
{
SpecificData::Ptr data = SpecificData::make({ .field1 = 13, .field2 = 42 });
return 0;
}
My issue is the warning which I get from gcc (trunk)
<source>:35:48: error: missing initializer for member 'SpecificData::<anonymous>' [-Werror=missing-field-initializers]
35 | SpecificData::Ptr data = SpecificData::make({ .field1 = 13, .field2 = 42 });
The compiler options used for compilation are:
-std=c++20 -Wall -Wextra -Wpedantic -Werror -O2
I know how to deactivate the warning, or in this case the error beacause of the -Werror, but I want to understand it first, why is it present in the first place.
I don't understand which field remains uninitialized in my SpecificData object.
Could it be the const Type type from the base class which causes the problem?
If not, is this a compiler bug?
Note : clang compiles the code without issue with the same flags, so does MSVC with similar flags.

Answer 1

There is nothing wrong with the code you are showing, but the warning may be intentional.
An aggregate class has several elements, in order its direct base classes, followed by its direct non-static data members.
When you use aggregate initialization (whether with designated initializers or not) you can either explicitly initialize any of these elements by writing an element corresponding to it in the initializer list, or have them be implicitly initialized.
Obviously there shouldn't be a warning for the explicitly initialized ones, but the question is whether every non-explicitly initialized element should produce the warning.
In general, it should be necessary to provide an initializer for every element, including the direct base class subobjects.
However, since C++11 it is possible to declare in-class default member initializers for non-static data members, which would be chosen in this scenario. This clearly signifies the intent to not need explicit initialization, so there is no warning for these.
Unfortunately there doesn't exist an analoguous syntax for base classes and so it is not possible to signify a proper "default" in aggregate initialization for them.
All remaining elements (non-static data members without default member initializer and direct base classes), are simply initialized as if by = {}. In your particular case the base class Data<SpecificData, Type::SpecificType> can be initialized just fine that way without leaving any subobject with indeterminate value, because it has a default constructor that will be chosen for the initialization and initialize the only member subobject (type) correctly.
But it isn't clear from the definition of SpecificData that this is permitted use. The warning isn't meant to warn about indeterminate values in non-initialized data members anyway, since aggregate initialization will never leave elements uninitialized. It is meant to warn that something has taken a default value through = {} initialization, that is likely a mistake.
To see that this is GCC's behavior (which I unfortunately couldn't find clearly defined in the documentation), consider the following two cases that also produce the warning:
struct Data
{
};
struct SpecificData : Data
{
int field1;
int field2;
};
int main()
{
// Data without explicit initializer
SpecificData d{ .field1 = 13, .field2 = 42 };
}
And
struct Data
{
};
struct Data2
{
};
struct SpecificData : Data, Data2
{
int field1 = 1;
int field2 = 2;
};
int main()
{
SpecificData d{{}}; // no explicit initializer for Data2
}