Narrowing conversions and brace initialisation safety

Understanding Narrowing conversions and brace initialisation safety

Copy-initialisation with = runs the ordinary implicit conversion rules, and those rules happily lose information: int n = 3.99; stores 3, short s = 40000; stores -25536 on a 16-bit short, and unsigned u = -1; stores 4294967295. The compiler may warn about some of these, and only with the right flags, but nothing in the language stops the conversion. List-initialisation with braces adds one extra rule on top of the very same conversions: if a required conversion is a narrowing conversion, the program is ill-formed and you get a diagnostic. So {} reads as "this value, in this type", and it fails the moment those two cannot both be true.

The standard lists the narrowing conversions explicitly, and the details decide what compiles. Floating-point to integer is narrowing with no exception at all, so int x{8.0}; is rejected even though 8 is exact and visible to the compiler. The other three cases, double to float, integer to floating-point, and integer to an integer type that cannot represent all source values, are exempt when the initialiser is a constant expression whose value survives the conversion. That is why short s{32767}; compiles and short s{32768}; does not, and why the check falls back to comparing the ranges of the types as soon as the value is not a compile-time constant.

The check follows the braces wherever they appear: scalar variables, each member of an aggregate, every element passed to an initializer_list constructor, arguments to a constructor chosen by list-initialisation, and the operand of return {...}. That makes braces a cheap audit of existing code, because int n{v.size()}; refuses to compile, and the truncation it names is exactly the bug you wanted to hear about. When the loss really is deliberate, write static_cast<int>(v.size()) instead; the rule exists to stop conversions happening by accident, not to forbid them.

#include <iostream>

int main() {
    // Assumes 16-bit short and 32-bit unsigned int.
    int          truncated   = 3.99;   // fraction dropped
    short        wrapped     = 40000;  // does not fit in short
    unsigned int wrapped_neg = -1;     // wraps to the largest unsigned value

    std::cout << truncated << ' ' << wrapped << ' ' << wrapped_neg << '\n';

    // The same three initialisations in braces do not compile:
    // int          a{3.99};   // floating point to integer is always narrowing
    // short        b{40000};  // constant, but 40000 does not fit in short
    // unsigned int c{-1};     // constant, but -1 does not fit in unsigned

    short  fits{32767};   // constant expression inside short's range
    int    widened{'A'};  // char to int loses nothing
    double promoted{7};   // 7 converts to double and back unchanged

    std::cout << fits << ' ' << widened << ' ' << promoted << '\n';
}

Worked examples

#include <iostream>

int main() {
    const int small = 100;   // constant expression
    short a{small};          // accepted: the value 100 fits in short

    int runtime = 100;       // same value, not a constant expression
    // short bad{runtime};   // error: narrowing conversion of 'runtime'
    short b{static_cast<short>(runtime)};

    float f{0.1};            // accepted: within float's range
    // int   n{0.1};         // error: no exemption for floating to integer

    std::cout << a << ' ' << b << ' ' << f << '\n';
}

#include <iostream>
#include <vector>

struct Pixel { int x; int y; };

int main() {
    std::vector<int> v{4, 8, 15};
    // int n{v.size()};               // error: size_t to int is narrowing
    int n{static_cast<int>(v.size())};

    // Pixel p{4, 8.0};              // error: double to int in a member
    Pixel p{4, 8};

    // std::vector<int> w{1, 2, 3.5}; // error: element of initializer_list<int>
    std::vector<double> w{1, 2, 3.5};

    std::cout << n << ' ' << p.x + p.y << ' ' << w.back() << '\n';
}

Important notes

Common mistakes

Try it yourself