Why does a narrowing conversion warning appear only in case of list initialization?

Question

I have the following code:

class A
{
    public:
        A(const unsigned int val) : value(val) {}

        unsigned int value;
};

int main()
{
    int val = 42;
    A a(val);
    A b{val};       // <--- Warning in GCC, error in Microsoft Visual Studio 2015

    return 0;
}

Why does the narrowing conversion warning appear only in case of list initialization usage?

Answer 1

list initialization was introduced since C++11 with the feature prohibiting implicit narrowing conversions among built-in types. At the same time, the other two "old-style" (since C++98) initialization forms which use parentheses and equal-sign like

int val = 42;
A a(val);
A a = val;

don't change their behavior to accord with list initialization, because that could break plenty of legacy code bases.

Answer 2

Under the standard, narrowing conversions are illegal in that context. They are legal in the other context. (By "illegal", I mean make the program ill-formed).

The standard requires that a compiler issue a diagnostic in that particular case (of making the program ill-formed). What the compiler does after emitting the diagnostic the standard leaves undefined.

MSVC chooses to halt compilation. Gcc chooses to emit nasal demons pretend the program makes sense, and do the conversion, and continue to compile.

Both warnings and errors are diagnostics as far as the standard is concerned. Traditionally errors are what you call diagnostics that preceed the compiler stopping compilation.

Also note that compilers are free to emit diagnostics whenever they want.

Traditionally warnings are used when you do something the standard dictates is a well formed program yet the compiler authors consider ill advised, and errors when the standard detects an ill-formed program, but most compilers do not enforce that strictly.