CODEWITHSUNDEEP
iosobjective-c
Nicolas Manzini
Nicolas Manzini

Reputation: 8546

Is it better to write 0.0, 0.0f or .0f instead of simple 0 for supposed float or double values

Hello well all is in the title. The question apply especially for all those values that can be like NSTimeInterval, CGFloat or any other variable that is a float or a double. Thanks.

EDIT: I'm asking for value assignment not format in a string.

EDIT 2: The question is really does assigning a plain 0 for a float or a double is worst than anything with f a the end.

Upvotes: 20

Views: 29482

Answers (4)

Anoop Vaidya
Anoop Vaidya

Reputation: 46543

The basic difference is as :

1.0 or 1. is a double constant

1.0f is a float constant

Without a suffix, a literal with a decimal in it (123.0) will be treated as a double-precision floating-point number. If you assign or pass that to a single-precision variable or parameter, the compiler will (should) issue a warning. Appending f tells the compiler you want the literal to be treated as a single-precision floating-point number.

Upvotes: 29

Hermann Klecker
Hermann Klecker

Reputation: 14068

Whether you use 0.0, .0, or 0.0f or even 0f does not make much of a difference. (There are some with respect to double and float) You may even use (float) 0.

But there is a significant difference between 0 and some float notation. Zero will always be some type of integer. And that can force the machine to perform integer operations when you may want float operations instead.

I do not have a good example for zero handy but I've got one for float/int in general, which nealy drove me crazy the other day.

I am used to 8-Bit-RGB colors That is because of my hobby as photographer and because of my recent background as html developer. So I felt it difficult to get used to the cocoa style 0..1 fractions of red, green and yellow. To overcome that I wanted to use the values that I was used to and devide them by 255. 

[CGColor colorWithRed: 128/255 green: 128/255 andYellow: 128/255];

That should generate me some nice middle gray. But it did not. All that I tried either made a black or white. First I thought that this was caused by some undocumented dificiency of the UI text objects with which I was using this colour. It took a while to realize that this constant values forced integer operations wich can only round up or down to 0 and 1. This expession eventually did what I wanted to achieve: 

[CGColor colorWithRed: 128.0/255.0 green: 128.0/255.0 andYellow: 128.0/255.0];

You could achieve the same thing with less .0s attached. But it does not hurt having more of them as needed. 128.0f/(float)255 would do either.

Edit to respond to your "Edit2": 

float fvar; 
fvar = 0;

vs ...

fvar = .0;

In the end it does not make a difference at all. fvar will contain a float value close to (but not always equal to) 0.0. For compilers in the 60th and 70th I would have guessed that there is a minor performance issue associated with fvar = 0. That is that the compiler creates an int 0 first which will then have to be converted to float before the assignment. Modern compilers of today should optimize automatically much better than older ones. In the end I'd have to look at the machine code output to see whether it does make a difference. However, with fvar = .0; you are always on the safe site.

Upvotes: 4

Inder Kumar Rathore
Inder Kumar Rathore

Reputation: 39988

If you are initializing a variable then it make no sense. compiler does all the cast for you.

float a = 0; //Cast int 0 to float 0.0
float b = 0.0; //Cast 0.0 double to float 0.0 as by default floating point constants are double
float c = 0.0f // Assigning float to float. .0f is same as 0.0f

But if you are using these in an expression then that make a lot of sense.

6/5 becomes 1
6/5.0 becomes 1.2 (double value)
6/5.0f becomes 1.2 (float value)

Upvotes: 8

Christoph
Christoph

Reputation: 1525

If you want to dig out if there is any difference to the target CPU running the code or the binary code it executes, you can easily copy one of the command lines compiling the code from XCode to command line, fix missing environment variables and add a -S. By that you would get assembly output, that you can use to compare. If you put all 4 variants in a small example source file, you can compare the resulting assembly code afterwards, even without being fluent in ARM assembly.

From my ARM assembly experience (okay... 6 years ago and GCC) I would bet 1ct on something like XORing a register with itself to flush it's content to 0.

Upvotes: 3

Related Questions