Constructor and initializer_list

Here is what I believe GCC is thinking.

This is your program with 1 extra line, and the interesting lines numbered.

int main() { A({1}); // 1. Compile OK f({1}); // 2. Compile OK A{{1}}; // 3. Compile OK, equivalent to 1. A({{{1}}}); // 4. Compile OK //f({{{1}}}); // 5. Compile Error. } 

Why does GCC compile 4 but not 5?

For clarity, suppose the construction at #4 actually declared something:

A a{{{1}}}; // 4a. Compile OK 

GCC asks if the argument of the constructor, which is {{1}} is implicitly convertible to A. So is:

A{{1}} 

a valid conversion from {{1}} to A? Yes it is - as per 3.

This reasoning, of course, is not applicable to #5; hence error.

If you want to stop GCC from accepting #4, then block the enabling conversion by making the enabling constructor explicit:

class A { public: explicit A(const std::initializer_list<int> il) {} }; 

Then #4 will give the error:

error: converting to ‘A’ from initializer list would use explicit constructor ‘A::A(std::initializer_list<int>)’ 

A {1} can initialize an int. A {{1}} probably should not - there is a defect report on tbe committee for that. GCC forbids that and clang just tends to emit warnings about redundant braces currently.

When X is a class that has copy or move constructors, then X ({...}) may invoke invoke one of them. Notice that X {...} may too, but is restricted to not allow user defined conversions (for a copy or move constructor).

Now with your A ({{{1}}}) the first brace is consumed by the copy/move constructor. The second goes to the initializer list recursively. And the third goes to the contained int.

According to the Standard, adding one more brace will break for A ({{{{1}}}}). Because the second brace would need to be consumed by a copy/move constructor of A but need a user defined conversion sequence. The same holds for A {{{{1}}}}, which is invalid for this reason too.