C++ How to correctly round a const float to unsigned int

Question

So I have a const float that has a range from 0.0 to 1.0. What is the correct way to cast this to an unsigned int either by rounding or truncating?

Would this be acceptable?

const float f=0.5f;
unsigned int i=static_cast<unsigned int>(f);

Answer 1

Yes, that's perfectly acceptable if you want to truncate, and if you don't care what happens with negative numbers or overflow.

If you want to round, call roundf first (or, if you want a different rounding rule than "half rounds away from zero", write your own code).

If you want to deal with negative numbers or overflow, you need to check before converting.

According to 5.2.9 in the standard, static_cast in this case is defined to give you the same value as unsigned int i(f). And I think most style guides would agree that the static_cast is preferred (as making casts explicit and noticeable is usually a good thing).

In more detail:

According to 4.9.1:

A prvalue of a floating point type can be converted to a prvalue of an integer type. The conversion trun- cates; that is, the fractional part is discarded. The behavior is undefined if the truncated value cannot be represented in the destination type.

I'm not sure exactly how the const-away works in C++14, but I believe it's not a qualification conversion, but part of the lvalue-to-rvalue conversion from 4.1.1:

A glvalue (3.10) of a non-function, non-array type T can be converted to a prvalue … If T is a non-class type, the type of the prvalue is the cv-unqualified version of T.

So, f has one lvalue-to-rvalue conversion from lvalue const float to rvalue float, then one floating-integral conversion from float to unsigned int, so by 4.0.1 it's a standard conversion, so by 5.2.9 it's valid as a static_cast.

Answer 2

Just add one half to round:

unsigned int i = static_cast<unsigned int>(f + 0.5);

Or nothing to truncate - what you have is fine (assuming f >= 0)

unsigned int i = static_cast<unsigned int>(f);