Inherited constructors ignore in-class initialization

Question

I have a class defined like this:

class ASTConcatenateLiteral : public ASTExpr {
    using ASTExpr::ASTExpr;
private:
    Type type_ = Type::nothingness();  // Type does not have a default constructor
};

This works fine with Clang. GCC, however, gives me an error message that makes me think it’s trying to use the default initializer:

error: no matching function for call to ‘EmojicodeCompiler::Type::Type()’

If I replace using ASTExpr::ASTExpr; with a public constructor like this (ASTExpr only provides exactly this constructor)

ASTConcatenateLiteral(const SourcePosition &p) : ASTExpr(p) {}

everything works fine.

According to cppreference.com:

The inherited constructors are equivalent to user-defined constructors with an empty body and with a member initializer list consisting of a single nested-name-specifier, which forwards all of its arguments to the base class constructor.

So why doesn’t the inherited constructor work? If the inherited constructor behaves like a user-defined constructors, it should use the value provided for type_, right? Which of the compilers is right according to the standard?

Answer 1

Clang is correct. When inherited constructor is used, the initialization should proceed as if a defaulted default constructor were used to initialize the object of the derived class, thus the default member initializers should be used.

(emphasis mine)

If overload resolution selects one of the inherited constructors when initializing an object of such derived class, then the Base subobject from which the constructor was inherited is initialized using the inherited constructor, and all other bases and members of Derived are initialized as if by the defaulted default constructor (default member initializers are used if provided, otherwise default initialization takes place).

Here's an example from the standard:

struct B1 {
  B1(int, ...) { }
};

struct B2 {
  B2(double) { }
};

int get();

struct D1 : B1 {
  using B1::B1;     // inherits B1(int, ...)
  int x;
  int y = get();
};

void test() {
  D1 d(2, 3, 4);    // OK: B1 is initialized by calling B1(2, 3, 4),
                    // then d.x is default-initialized (no initialization is performed),
                    // then d.y is initialized by calling get()
  D1 e;             // error: D1 has a deleted default constructor
}

Note that d.y is initialized by the default member initializer.