¿Cuál es el significado de 0.0f al inicializar (en C)?

He visto un código en el que las personas inicializan variables flotantes como esta:

float num = 0.0f; 

¿Hay una diferencia significativa entre esto y simplemente hacer lo siguiente a continuación?

 float num = 0; 

Gracias.. 🙂

float x = 0 tiene un typecast implícito de int a float.
float x = 0.0f no tiene un tipo de transmisión.
float x = 0.0 tiene un typecast implícito del doble al float.

Dependiendo del comstackdor, el typecast implícito puede requerir que el comstackdor genere código adicional.

Se considera una buena práctica inicializar una variable con una constante literal del mismo tipo. En este caso, tiene una variable flotante y debe inicializarla con una constante literal flotante, es decir, 0.0f , en lugar de una int ( 0 ) que luego se convierte implícitamente en un flotante.

Probablemente la razón es que una vez escribieron algo así como:

 float f = 1 / i; // i an integer 

Habiendo depurado eso, juraron siempre decorar literales lo suficiente para obtener el tipo correcto:

 float f = 1.0f / i; 

En este caso, el .0 es para asegurar que la división sea de coma flotante, no de división entera. La f es porque no hay necesidad de que la operación se realice en double . Espero que haya más posibilidades de una implementación en la que 1.0/i sea ​​significativamente más lento sin beneficio (emulación de flotación de software, optimización indiferente) que uno donde 1.0f es significativamente más lento sin ningún beneficio (si el doble es más rápido que el flotante, eso se debe a que tiene hardware fp, por lo que la conversión entre los dos será muy rápida, por lo que no se presentará una desaceleración significativa ).

Una vez que tienes el hábito de decorar literales, puedes escribir:

 float f = 0.0f; 

a pesar de que tiene exactamente el mismo efecto que float f = 0.0; o float f = 0; .

Por supuesto, es posible que el autor no haya pasado por esta revelación personalmente, sino que simplemente haya heredado el estilo de otra persona que sí lo hizo.

Solo escribiría 0 .

R .. señala en un comentario y otra respuesta que escribir 0 también tiene el beneficio de que cuando cambie el tipo de f en el futuro, no tiene que actualizar el literal para que coincida. Y si la tarea es separada de la definición, entonces cambia:

 float f = something // some time later f = 0.1f; 

a:

 double f = something; // some time later f = 0.1f; 

es probablemente un error. Es mejor usar 0.1 y dejar que el comstackdor trunque flote si es necesario. Probablemente puedas argumentar que usar float es una optimización, por espacio si no por tiempo, y la carga de lidiar con cualquier diferencia entre float y double debe contarse como un costo de desarrollador para realizar esa optimización.

Bueno, en sentido estricto, 0 es un número entero, por lo que float num = 0 requiere una conversión de entero a flotante. Pero supongo que el comstackdor hace esto por ti de todos modos. Supongo que las personas usan 0.0f para enfatizar que esto es un flotador, por lo que nadie lo confunde con un entero.

Paul R ha escrito la respuesta. Su segundo ejemplo tiene un valor de inicialización entero.

Siempre debe usar un inicializador del mismo tipo que la variable que se está inicializando. Esto evita cualquier conversión en tiempo de comstackción (idealmente) o tiempo de ejecución (comstackdores perezosos: ¿hay alguno así de perezoso?). Y quizás lo más importante, la conversión puede llevar a algunas cosas extrañas en el caso general.

Aquí la conversión debería hacer exactamente lo que se espera, pero sigue siendo un buen estilo y evita una advertencia del comstackdor.

‘f’ indica que quieres un flotador:

0 es un int

0f es un flotador

0.0 es un doble

0.0f es un flotador

No veo ninguna razón para usar esto para el proceso de inicialización. Pero, para las operaciones que involucran literales de punto flotante, esto sería útil. Por ejemplo;

 float a=0.43, b; b = 0.5*a + 2.56*a*a; 

Los literales de coma flotante sin sufijo se consideran dobles. Entonces, para este cálculo, “a” se duplicará y la respuesta final de la evaluación RHS será doble. Durante la asignación, el doble valor de RHS se invierte para flotar y se asigna a “b”. Esto degradaría el rendimiento si la máquina no tiene FPU de doble precisión. Para evitar esto, usa flotación para todo el cálculo. se usan sufijos Por ejemplo,

 float a=0.43, b; b = 0.5f*a + 2.56f*a*a;