66

What is the difference between

float f = (float) 99.32 ;

and 

float f = 99.32f ;

Both of them compiled and ran successfully.

Improve this question
4
  • 15
    The first suffers from double rounding error, which is not good as the result might not be the desired value. The second one produces a correctly rounded float value en.wikipedia.org/wiki/Rounding#Double_rounding Commented Oct 16, 2015 at 8:15
  • That link uses way too long a representation of its example number. "0.50000008940696713" is sufficient. Commented Oct 16, 2015 at 16:13
  • @LưuVĩnhPhúc: I expect it used a precise decimal representation of a value halfway between two adjacent double values, though I would suggest that adding a large integer to the value would make precise decimal representations much shorter and more obvious. Commented Oct 16, 2015 at 19:09
  • 1. Do you mean, for that decimal string specifically, or for any one? 2. What does "successfully" mean? "Returned the same value"? (Do they test as equal? Did you examine the entire representation?) Commented Oct 21, 2015 at 8:38

6 Answers 6

Reset to default
87 
float f = 99.32f ;

That is a float literal, which means a float variable being assigned with a float value directly.

float f = (float) 99.32 ;

That is a float variable that is assigned a double value that is cast to float before being assigned.

Improve this answer
Sign up to request clarification or add additional context in comments.

22 Comments

Would the compiler optimize this out? (in the cast case)
no, 99.32 is a floating point literal, which has the type double.
no, 99.32 is a double, not implicit casted to it. This is called "floating point literal of type double". 99.32f is a float and not casted to it. This is called "floating point literal of type float". There is no cast at float f = 99.32f; or double d = 99.32;.
Is there any difference in value between the two?
@JanDvorak: Rare, and likely not in this case. (float) 99.32 is the real number 99.32, rounded to the nearest available double number, rounded to the nearest available float number. 99.32f is the real number 99.32, rounded to the nearest float number. Let x be a number that is exactly halfway between two neighbouring float numbers. Let d and d' be two decimal numbers that is just a tiny tiny bit larger/smaller than x. Then the .f suffix would be rounded up/down, but rounding to double might give the result x in both cases, and casting to float will round either d or d' in the wrong direction.
|
25

The difference may be optimized away, but in the first case you have a double literal that is type casted to a float while you have a float literal in the second case.

If not optimized away you will get a typecast in the code in the second example.

However there are corner cases where the result could (depending on rounding mode) be slightly different. If your number can't be exactly represented you will in the first case get rounding twice - first when you round the decimal representation to a double and then when you round that to a float, while in the first case you round the decimal representation directly to a float.

Improve this answer

7 Comments

Since an ULP in single-precision is so much larger than an ULP in double precision, I find it hard to believe the doubled rounding could have a significant effect.
@Kevin It would have an effect of up to one float ULP difference.
I suspect a corner case does exist, but have not found it.
0.50000008940696713 yields a different result: with rounding you get 0x1.000004p-1 while with suffix you get 0x1.000002p-1 (see ideone.com/EV3QeG). See also en.wikipedia.org/wiki/Rounding#Double_rounding
More specifically, last two digits of 11-21 all result in 0x1.000003p-1 as double (and therefore 0x1.000004p-1 when double-rounded to float), and last two digits of 11-16 (roughly half of this range) result in 0x1.000002p-1. So the range of values over which this can occur (for each instance, presumably spaced one float ULP apart) is roughly one half of one double ULP wide, and in every case yields an "error" of one half of one float ULP when rounded up or down, since the real values are roughly halfway between two float values.
|
11

In the first case without the cast 99.32 is interpreted as double not as a float.

A double literal is being casted to float.

In the second case you have a suffix f to make sure the compiler treats 99.32 as float.

Improve this answer

Comments

11

In the line float f = (float) 99.32; the literal 99.32 is created as a double type by default and is then cast to a float.

In the line float f = 99.32f ; the literal is created as a float type due to the trailing f in 99.32f and no type casting is required.

The latter would be analogous to writing double f = 99.32; as you'd have a double type being assigned directly to a variable of a matching type.

Improve this answer

Comments

10

Floating point literals without a suffix are by default of double type.

Thus, stating float f = (float) 99.32; you first cast explicitly literal 99.32 which is of type double to a float and then assign it to variable f.

Stating float f = 99.32; does the same thing but in this case the conversion between types is done implicitly.

If you want to avoid implicit conversion you should use the f suffix to define your literal (i.e., float f = 99.32f;)

Improve this answer

1 Comment

no they're not the same thing, without the f suffix the result is sometimes wrong
6

The difference is that the literal 99.32 is of type double, while the literal 99.32f is of type float.

The first statement assigns the float literal to a float variable. Nothing special.

The second statement casts a double literal to a float, and assigns the result to a float variable.

As far as the standard is concerned, you can assign a double literal to a float variable, without explicitly casting it yourself. In that case implicit cast occurs. E.g. :

float f = 99.32;

You can even do :

float f = (double) 10.5f;

and the right hand side is still implicitly converted to a float.

Please note that most modern compilers optimize those away, so representing floats is usually matter of style and preference. Just be consistent.

Improve this answer

1 Comment

This's wrong, they're not purely for consistency but they're required for accuracy. Without the f suffix the result is sometimes wrong. Always use f for float and L for long double