将float转换为int会截断其余部分，似乎不可靠

Question

Being somehow surprised seeing things like this work:

float f = 10.25f;
int i = (int)f;
// Will give you i = 10

What is the gain?

OTOH 10.25 is quite a different thing than 10, which will be agreed, bad things might happen from such a soft conversion.

Which languages raise an error instead?

Would expect someting like: "Error: Can't represent 10.25 as an integer" .

WRT to answers given meanwhile: Yes, it might considered reliable the way a function like "round" is. But not straight WRT to integrity of data/information to be expected from cast.

Maybe a function "truncate" which defaults to behavior of "int" would make a better choice?

Answer 1

It is precisely the

(int)f

that tells that the programmer is aware of what he is doing, while silently cutting off the fractional part and storing the rest in an integer is forbidden in most programming languages.

By the way, it is not just that the fractional part is cut off. It is also that a floating point number can have a value so large that it can't possibly be represented as an int. Consider:

(int) 1e20f

Answer 2

The statement int i = (int)f; explicitly says "Please take my float f and make it into int ". This is certainly something I quite often find a useful thing to do - why wouldn't you want to be able to convert a float value from a calculation of some sort to an integer? The cast (int) will tell the compiler that "I really want this to be an integer", just like in C you can do char *p = (char *)1234567; - a typecast is there to tell the compiler "I really know what I'm doing".

If you do int i = f; or int i = 10.25; the compiler will still do what you "asked for" - convert the float value to an integer. It will probably issue a warning to say "You are converting a float to int ", if you enable the appropriate warnings.

C and C++ are languages that require you to understand what you are doing, and what the consequences are - some other languages put more "barriers" in place to prevent such things, but that often means that the compiler has to add extra code to check things at runtime - C and C++ are designed to be "fast" languages.

It's a bit like driving a car, putting the car in reverse when there is a wall right behind, and stepping on the gas, will probably cause the car to crash into the wall - if that's not what you want, then "don't do that".

Answer 3

Firstly, the conversion is most definitely "reliable", as in "it will always do the same thing".

Whether you want to do that or not is up to you. In general the C/C++ languages are designed to give the programmer a lot of low-level power, and that means that the programmer needs to know what they are doing . If a float-to-int conversion surprises you then you need to think harder.

In fact, GCC has an option -Wconversion that will highlight cases like this. It isn't enabled by default, and is not part of -Wall or -Wextra (presumably because the behaviour is well understood and "expected" by most programmers), but the option is there if you need it.

Except that it won't give a warning, in this case, because your code includes an explicit cast (int) , so the compiler assumes you did it deliberately.

This gives a warning (with -Wconversion ):

int i = f;

This does not:

int i = (int)f;

Answer 4

Converting to an integer is useful in cases where you are working with complex data, but ultimately need to convert this data to an int to do something with it. Think of offsets in arrays, or pixels on a screen

Think of drawing a circle on the screen. There does not exist a fraction of a pixel (so the coordinates are ints), but you cannot calculate the coordinates of the pixel with just ints (sinus works with pi and other floats).