Do I need to use decimal places when using floats? Is the "f" suffix necessary?

I've seen several examples in books and around the web where they sometimes use decimal places when declaring float values even if they are whole numbers, and sometimes using an "f" suffix. Is this necessary?

For example:

[UIColor colorWithRed:0.8 green:0.914 blue:0.9 alpha:1.00];

How is this different from:

[UIColor colorWithRed:0.8f green:0.914f blue:0.9f alpha:1.00f];

Does the trailing "f" mean anything special?

Getting rid of the trailing zeros开发者_JAVA百科 for the alpha value works too, so it becomes:

[UIColor colorWithRed:0.8 green:0.914 blue:0.9 alpha:1];

So are the decimal zeros just there to remind myself and others that the value is a float?

Just one of those things that has puzzled me so any clarification is welcome :)

Decimal literals are treated as double by default. Using 1.0f tells the compiler to use a float (which is smaller than double) instead. In most cases it doesn't really matter if a number is a double or a float, the compiler will make sure you get the right format for the job in the end. In high-performance code you may want to be explicit, but I'd suggest benchmarking it yourself.

As John said numbers with a decimal place default to double. TomTom is wrong.

I was curious to know if the compiler would just optimize the double to a const float (which I assumed would happen)... turns out it doesn't and the idea of the speed increase is actually legit... depending on how much you use it. In math-heavy application, you probably do want to use this trick.

It must be the case that it is taking the stored float variable, casting it to a double, performing the math against the double (the number without the f), then casting it back to a float to store it again. That would explain the diference in calculation even though we're storing in floats each time.

The code & raw results: https://gist.github.com/1880400

Pulled out relevant benchmark on an iPad 1 in Debug profile (Release resulted in even more of a performance increase by using the f notation):

------------ 10000000 total loops
timeWithDoubles: 1.33593 sec
timeWithFloats: 0.80924 sec
Float speed up: 1.65x
Difference in calculation: -0.000038

Code:

int main (int argc, const char * argv[]) {
  for (unsigned int magnitude = 100; magnitude < INT_MAX; magnitude *= 10) {
    runTest(magnitude);
  }
  return 0;
}

void runTest(int numIterations) {
  NSTimeInterval startTime = CFAbsoluteTimeGetCurrent();
  float d = 1.2f;
  for (int i = 0; i < numIterations; i++) {
    d += 1.8368383;
    d *= 0.976;
  }
  NSTimeInterval timeWithDoubles = CFAbsoluteTimeGetCurrent() - startTime;

  startTime = CFAbsoluteTimeGetCurrent();
  float f = 1.2f;
  for (int i = 0; i < numIterations; i++) {
    f += 1.8368383f;
    f *= 0.976f;
  }
  NSTimeInterval timeWithFloats = CFAbsoluteTimeGetCurrent() - startTime;
  printf("\n------------ %d total loops\n", numIterations);
  printf("timeWithDoubles: %2.5f sec\n", timeWithDoubles);
  printf("timeWithFloats: %2.5f sec\n", timeWithFloats);
  printf("Float speed up: %2.2fx\n", timeWithDoubles / timeWithFloats);
  printf("Difference in calculation: %f\n", d - f);
}

Trailing f: this is a float.

Trailing f + "." - redundant.

That simple.

8f is 8 as a float.

8.0 is 8 as a float.

8 is 8 as integer.

8.0f is 8 as a float.

Mostly the "f" can be style - to make sure it is a float, not a double.