¿Cuál es la importancia de 0.0f al inicializar (en C)?

Question

que he visto código donde la gente inicializar variables float así:

float num = 0.0f; 

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

float num = 0; 

Gracias .. :)

Answer 1

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.

Según el compilador, el tipo de difusión implícita puede requerir que el compilador genere código adicional.

Answer 2

Bueno, estrictamente hablando, 0 es un número entero, por lo que requiere un casting float num = 0 desde un entero flotar. Pero supongo que el compilador 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.

Answer 3

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 compilación (idealmente) o tiempo de ejecución (compiladores 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 debe hacer exactamente lo que se espera, pero sigue siendo un buen estilo y evita una advertencia del compilador.

Answer 4

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.

Answer 5

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

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

Habiendo depuradas que, juraron siempre para decorar literales suficiente como 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. El f se debe a que no es necesario realizar la operación en double. Espero que exista una mayor probabilidad de una implementación donde 1.0/i sea significativamente más lento sin beneficio (emulación de flotación de software, optimización indiferente) que con 1.0f significativamente más lento sin 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 tanto, no introduzca reducción significativa de).

uno que usted tiene el hábito de literales de decoración, que bien podría 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, que simplemente haya heredado el estilo de otra persona que sí lo hizo.

Me gustaría escribir 0.

R .. señala en un comentario una respuesta más que escribir 0 también tiene la ventaja de que cuando cambie el tipo de f en el futuro, no tiene que actualizar el literal para hacer coincidir. Y si la asignación es independiente de la definición, a continuación, cambiar:

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 compilador trunque flote si es necesario. Probablemente podría argumentar que usar float es una optimización, por espacio si no es por tiempo, y la carga de lidiar con cualquier diferencia entre flotante y doble debe contarse como un costo de desarrollador para realizar esa optimización.

Answer 6

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;