# float x = 1.33333333333333 why does it equal 1?

## Recommended Posts

Hi, I have made a float like so float x = 400/300 400/300 = 1.333333333333333333333333333333333 When i find out what value x is like so this.text = x.tostring(); text = 1 for some reason Do recurring numbers get rounded off if so, how can i keep it so x = 1.3333? Thanks for any info

##### Share on other sites
because you are doing an integer division.

float x = (float)400/300

That will do what you want.

##### Share on other sites
If both numbers on either side of a division are integers a ‘integer division’ is performed. This is basicly a division that is trunctuated to an integer (for the sake of speed). To solve this you can cast the values as floats or doubles.

Example:

Floats:
400.0f / 300.0f

Floats:
( float ) 400 / (float ) 300

Doubles:
400.0 / 300.0

Hope this helps,
Jackson Allan

##### Share on other sites
Quote:
 Original post by Xetrovbecause you are doing an integer division.float x = (float)400/300

Casting literals is strange. Why not this?

    float x = 400.0f / 300.0f

##### Share on other sites
Quote:
 Casting literals is strange. Why not this? float x = 400.0f / 300.0f

Fair enough, but that doesnt exactly work when you want to use variables instead ;)

##### Share on other sites
Quote:
 Original post by XetrovFair enough, but that doesnt exactly work when you want to use variables instead ;)

(Kicking the man while he's down.)
C casts are evil (unless you're programimng in pure C).
Prefer static_cast<float>(a)/b.
That way it is obvious what the cast is applied to.
(does the cast in (float)a/b apply to a or to a/b ?)

[wink]

##### Share on other sites
I see :)
Thanks everyone :)

##### Share on other sites
Quote:
 Original post by FrunyPrefer static_cast(a)/b. That way it is obvious what the cast is applied to.(does the cast in (float)a/b apply to a or to a/b ?)

Although C-casts are ugly, I usually find this nice:
float(a)/b

##### Share on other sites
That's not a C cast, you're creating a temporary float from a. I guess in the end it's exactly the same, but I'm going to say they're different, so har!

##### Share on other sites
Quote:
Original post by dalleboy
Quote:
 Original post by FrunyPrefer static_cast(a)/b. That way it is obvious what the cast is applied to.(does the cast in (float)a/b apply to a or to a/b ?)

Although C-casts are ugly, I usually find this nice:
float(a)/b

float x = (float)(a/b) is the way I did

##### Share on other sites
Quote:
 Original post by Archifloat x = (float)(a/b) is the way I did
I don't think that'll work. The integer divide would happen before the float cast.

##### Share on other sites
I think the OP would have known why it was 1 if he was using integer variables (cause he seemed to already understand the fact that his type being float was important) ... so it seems he was only surprised by the fact that:

float f = 300/400;

is using an integer 300 and an integer 400 when the compiler could clearly see the result is float ...

I think the thing he (and many others) didn't know is that all literals are inheirently typed ... all the time - even in #define statements.

100 is always an integer, and (if memory serves) 100.0 is always a double (correct me if i'm wrong here).

Hence the reason you see:

100.0f (makes it be a float instead of a double)

and also of course
0144 // 100 as an octal number
0x64 // 100 as a hex constand

##### Share on other sites
Quote:
 I think the OP would have known why it was 1 if he was using integer variables (cause he seemed to already understand the fact that his type being float was important) ... so it seems he was only surprised by the fact that:float f = 300/400;is using an integer 300 and an integer 400 when the compiler could clearly see the result is float ...

but

float f = 25/5;

wouldn't be so obvious would it? hence the convention...

##### Share on other sites
what convention? I think there was a minor misunderstanding .. I know the reasons why the C / C++ compiler acts the way it does, and believe it makes complete sense. And here's the real reason - if the user WANTS this float to be initialize based on integral arithmatic, he/she needs that option.

All I was saying in my last post was: I think the OP and others like him need to be informed about the fact that all literals are typed (and therefore follow almost exactly the same rules as if they we're variables of their type), and how to select their type, more than about types, casts, and expression evaluation in general (most C/C++ people learn the basic expression evaluation fairly early).

##### Share on other sites
Quote:
Original post by dalleboy
Quote:
 Original post by FrunyPrefer static_cast(a)/b. That way it is obvious what the cast is applied to.(does the cast in (float)a/b apply to a or to a/b ?)

Although C-casts are ugly, I usually find this nice:
float(a)/b

That's a function-style cast, which was added in C++.

##### Share on other sites
It's not a function, it's a constructor call (although it may be refered to as a function style cast) - it is only available on types which implement a constructor taking the single parameter of the appropriate type ...

##### Share on other sites
Quote:
 Original post by XaiIt's not a function, it's a constructor call (although it may be refered to as a function style cast) - it is only available on types which implement a constructor taking the single parameter of the appropriate type ...

Hence more appropriate in generic programming.

## Create an account

Register a new account

• ### Forum Statistics

• Total Topics
628402
• Total Posts
2982470

• 9
• 10
• 9
• 19
• 24