C++ allows "inheriting" constructors with a special rule for using-declarations. It also has a special rule for constructors that take std::initializer_list which changes the syntax for the constructor call.
These two rules don't work consistently together. The special syntax for constructors with std::initializer_list doesn't get inherited in all cases. In the example below the line "B b1 {};" fails to compile because it tries to call A() instead of A{}. Technically the constructors are inherited correctly. It's the special syntax for initializer lists that doesn't get inherited in the edge case of empty {} brackets. But it is inherited in all other cases.
I'm not entirely sure if this is a language issue or a compiler one as I can't fully comprehend the C++ standard but both gcc and clang would fail to compile this example code and give the same reason.
This language has too many special cases. Let's not have another one. Currently, the struct C in the example code is a working workaround for the issue.
#include<initializer_list>
struct A { A(std::initializer_list<int> il) {}; };
struct B : A { using A::A; };
struct C : A { C(std::initializer_list<int> il) : A(il) {}; };
int main()
{
// A(); // doesn't work, as expected
A{}; // works as expected
A a1 {}; // ok
A a2 {1, 2, 3}; // ok
A a3 {5}; // ok
B b1 {}; // calls A() instead of A{} so it fails
B b2 {1, 2, 3}; // ok
B b3 {5}; // ok
C c1 {}; // ok
C c2 {1, 2, 3}; // ok
C c3 {5}; // ok
return 0;
}