Clang rejects inheritance program that gcc and msvc accepts

This is a C++20 feature called parenthesized initialization of aggregates that clang has not yet implemented. That is, the program is well-formed from C++20 onwards. This can be seen from compiler support documentation:

As we can see in the above table, the entry for clang is empty/blank meaning that this feature has not been implemented in clang as of now.

Now let's look at how exactly this program is well-formed in c++20.

From direct initialization:

T object ( arg );          (1) 

The effects of direct initialization are:

• If T is a class type,
  • otherwise (from C++20), if the destination type is a (possibly cv-qualified) aggregate class, it is initialized as described in aggregate initialization except that narrowing conversions are permitted, designated initializers are not allowed, a temporary bound to a reference does not have its lifetime extended, there is no brace elision, and any elements without an initializer are value-initialized.

(emphasis mine)

This means that since Derived is an aggregate class, aggregate initialization will be performed for Derived d(1); from C++20.

Note also that Derived is an aggregate from C++17 onwards but Derived d(1); is aggregate initialization only from C++20 onwards due to P0960R.

Now from aggregate initialization:

The effects of aggregate initialization are: 2) Determine the explicitly initialized elements of the aggregate as follows:

• Otherwise, if the initializer list is non-empty, the explicitly initialized elements of the aggregate are the first n elements of the aggregate, where n is the number of elements in the initializer list. 3) Initialize each element of the aggregate in the element order. That is, all value computations and side effects associated with a given element are sequenced before those of any element that follows it in order (since C++11).

(emphasis mine)

This means that the base class subobject of the derived object is the explicitly initialized element of the aggregate and it will be copy initialized as per Initializing elements:

For each explicitly initialized element:

• Otherwise, the element is copy-initialized from the corresponding initializer clause of the initializer list:
  • If the initializer clause is an expression, implicit conversions are allowed as per copy-initialization, except that narrowing conversions are prohibited (since C++11).

(emphasis mine)

This means that the base subobject will be initialized as per the rules of copy initialization with the expression 1 as the initializer. Thus the program is well-formed from C++20 onwards and gcc and msvc are correct in accepting the program. OTOH, clang has not yet implemented this feature.

Though the other answers have identified why it works in some compilers (because they support "parenthesized initialization of aggregates") it seems to me that this is not what you intend.

It looks to me like you expect the derived class to inherit the constructor from the base class. That does not happen in C++ though; constructors are not inherited. Or at least not inherited in such a way that they become constructors of the derived type.

To fix your program:

class Derived : public Base
{ 
public:
   Derived(int arg) : Base(arg) { } 
};

and, presto, now your code is good old C++98—almost! If we get rid of #include <array>, it compiles with g++ -std=c++98. Plus I think it has to be <iostream.h> in true C++98.

Anyway, without this constructor, the parenthesized initialization d(1) requires the C++20 support which performs the equivalent of this:

   Derived d = { 1 }

but you really don't want to be doing either of these. Which means that the C++20 feature is kind of a misfeature which has taken away a diagnostic, replacing it with behavior you don't want. You don't want a class which has constructors to be brace initialized; it violates encapsulation.

The code is valid C++20, but not all C++20 features are supported by all compilers. You've run into a feature (parenthesized initialization) which Clang does not yet have.

This kind of thing happens with each new C++ standard. The support can seem nearly complete the year a standard is released, but with a few missing bits which can take several years to appear (if ever).