1

I believe I should type less if it's possible. Any unnecessary keystroke takes a bit a time. In the context of objective-C, my question is:

Can I type this 

[UIColor colorWithRed:0 green:0 blue:0 alpha:0.15]; [UIColor colorWithRed:0.45 green:0.45 blue:0.45 alpha:0.15];

or do I have to use the f suffix

[UIColor colorWithRed:0.0f green:0.0f blue:0.0f alpha:0.15f]; [UIColor colorWithRed:0.45f green:0.45f blue:0.45f alpha:0.15f];

1) why does it work even without "f"?

2) If I need to write f, do I still have an exception for "0", that means if it's zero, is it still ok without "f"?

Improve this question
2
  • 3
    The idea that you should type less is false, most projects spend the majority of their time in maintenance where readability of code is very important. I would add this as a comment, but I don't have the reputation yet... Commented Apr 11, 2014 at 13:15
  • I need to make my statement more clear it seems. I believe I should not type more than necessary to achieve high quality code. Anything that is redundant is actually waste of time and a potential bug entry point. Commented Apr 11, 2014 at 15:10

4 Answers 4

Reset to default
6

What you are really asking is about type literals and implicit casting.

I haven't written C in ages, but this reference leads me to believe it's not dissimilar to C# (I can't speak about objective-c)

The problem boils down to this:

  • 0.0 is a literal notation for the value 0 as a double
  • 0.0f is a literal notation for the value 0 as a float
  • 0 is a literal notation for the value 0 as a int

Supplying an int when a float is expected is fine, as there exists an implicit cast from int to float that the compiler can use.

However, if you specify a double when a float is expected, there is no implicit cast. This is because there is a loss of precision going from double to float and the compiler wants you to explicitly say you're aware of that.

So, if you write 0.0 when a float is expected, expect your compiler to moan at you about loss of precision :)

P.S.

I believe I should type less if it's possible. Any unnecessary keystroke takes a bit a time.

I wouldn't worry too much about the number of keystrokes. You'll waste far more time on unclear code in your life than you will from typing. If you're time concious then your best bet is to write clear and explicit code.

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

Comments

1

When you type 0 that is an integer constant. If you then assign it to a float, it gets promoted automatically: this is similar to a typecast but the compiler does it automatically.

When you type 0.0f that means "zero floating point" which is directly assigned to the float variable.

There is no meaningful difference between either method in this case.

Improve this answer

6 Comments

In this case. To the OP be careful when using auto casting in less trivial cases, floats assumed to be ints don't always work as you would expect.
I thought about that before submitting my answer, and I was hard-pressed to think of an integer constant that would cause problems when automatically promoted to a float. There are numbers that IEEE floats cannot represent with 100% accuracy for example, but these are no more accurate when using a float constant.
And for the record I always prefer to use proper constant types in my code. In this example, I would use 0.0f because it more accurately describes my intent.
@JohnGaughan Out of curiosity, what would happen if the size of int is equal or greater than the size of float on some system?
Then we will have found a hardware implementation of Java's BigInteger.
|
1

The fact that you are asking this question, indicates that you should be explicit, despite the extra keystroke. The last thing any programmer wants to do when starting to work on some code is say "WTF is happening here". Code is read more often than it is written, and you've just demonstrated that someone with your level of experience may not know what that code does.

Yes it will work, and no, there's no compile/runtime downside of doing so, but code should be written for other people not the compiler -- the compiler doesn't care what junk you write, it will do it's best with it regardless. Other programmers on the other hand may throw up their hands and step away from the keyboard.

Improve this answer

Comments

0

In both cases, the compiled code is identical. (Tested with LLVM 5.1, Xcode 5.1.1.)

The compiler is automatically converting the integer, float and double literals to CGFloats. Note that CGFloat is a float on 32-bit and a double on 64-bit, so the compiler will make a conversion whether you use 0.15f or 0.15.

I advise not worrying about this. My preference is to use the fewest characters, not because it is easier to type but because it it easier to read.

Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.