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?

songyuanyao · Accepted Answer · 2016-12-25T14:27:01.257

18

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.

edited Dec 25 '16 at 14:27

answered Dec 25 '16 at 14:06

songyuanyao

169,198
16
310
405

3

Is there a compiler flag to introduce that prohibition consistently? – Schwern Dec 25 '16 at 17:46
`int i = 0; char c[] = { i };` was an old-style initialisation form too, valid C++03 but invalid C++11. Legacy code *was* in fact broken by the change. – Dec 25 '16 at 23:12
@Schwern `-Wsign-conversion` seems to work for me on GCC and Clang, no idea for MSVC. – Gabriel Devillers May 14 '20 at 16:31
And for MSVC it seems C4365 works but [others](https://stackoverflow.com/a/3377243) may also be required. – Gabriel Devillers May 14 '20 at 16:40

score 9 · Answer 2 · answered Dec 25 '16 at 14:16

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.

Until C99 added the #error directive, an implementation could have satisfied all requirements for diagnostics by unconditionally outputting "This is a diagnostic" before it even looked at any of the source text. The Standard defines the #error directive much more explicitly, but still leaves all other requirements uselessly vague. — supercat, Dec 25 '16 at 22:55

score 0 · Answer 3 · answered Dec 25 '16 at 14:44

0

The reason behind the warning is already explained by other answers.

This is how to fix this warning/error. Create a constructor which takes initializer_list as argument.

A(std::initializer_list<int> l) : value(*(l.begin())) { 
    cout << "constructor taking initializer list called\n";
}

answered Dec 25 '16 at 14:44

Saurav Sahu

13,038
6
64
79

2

This "fix" is nonsensical. To allow `int val = 0; A b{val};`, you add code allowing `A b1{1,2,3,4,5};` and disallowing `unsigned int val = 42; A c{val};`. – T.C. Dec 25 '16 at 23:41

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

3 Answers3

Linked

Related