Comparación de un flotador con un valor en C

Prediga la salida del siguiente programa en C. 

#include<stdio.h>
int main()
{
    float x = 0.1;
    if (x == 0.1)
        printf("IF");
    else if (x == 0.1f)
        printf("ELSE IF");
    else
        printf("ELSE");
}

La salida del programa anterior es » ELSE IF «, lo que significa que la expresión «x == 0.1» devuelve falso y la expresión «x == 0.1f» devuelve verdadero. 

Consideremos el siguiente programa para comprender la razón detrás de la salida anterior.  

#include<stdio.h>
int main()
{
   float x = 0.1;
   printf("%d %d %d", sizeof(x), sizeof(0.1), sizeof(0.1f));
   return 0;
}

The output of above program is "4 8 4" on a typical C compiler.
It actually prints size of float, size of double and size of float.

Los valores utilizados en una expresión se consideran dobles ( formato de punto flotante de precisión doble ) a menos que se especifique una ‘f’ al final. Entonces, la expresión «x==0.1» tiene un doble en el lado derecho y un flotante que se almacena en un formato de punto flotante de precisión simple en el lado izquierdo. En tales situaciones, la flotación se promueve al doble (ver esto ). El formato de precisión doble utiliza más bits para la precisión que el formato de precisión simple. 

El equivalente binario de 0.1 ₁₀ se puede escribir como (0.00011001100110011…) ₂ que va hasta el infinito (Consulte este artículo para obtener más información sobre la conversión). Dado que la precisión de float es menor que el doble, después de cierto punto (23 en float y 52 en double) se truncaría el resultado. Por lo tanto, después de la promoción de float a doble (en el momento de la comparación), el compilador rellenará los bits restantes con ceros. Por lo tanto, obtenemos el resultado diferente en el que el equivalente decimal de ambos sería diferente. Por ejemplo, 

In float 
=> (0.1)10 = (0.00011001100110011001100)2
In double after promotion of float ...(1)
=> (0.1)10 = (0.00011001100110011001100000000000000000...)2
                                      ^ padding zeroes here
In double without promotion ... (2)
=> (0.1)10 = (0.0001100110011001100110011001100110011001100110011001)2

Hence we can see the result of both equations are different.
Therefore 'if' statement can never be executed.

Tenga en cuenta que la promoción de float a double solo puede causar una discrepancia cuando un valor (como 0.1) usa más bits de precisión que los bits de precisión simple. Por ejemplo, el siguiente programa en C imprime «IF».

#include<stdio.h>
int main()
{
    float x = 0.5;
    if (x == 0.5)
        printf("IF");
    else if (x == 0.5f)
        printf("ELSE IF");
    else
        printf("ELSE");
}

Producción: 

IF

Aquí el equivalente binario de 0.5 ₁₀ es (0.100000…) ₂ 

(No se perderá precisión tanto en el tipo flotante como en el doble). Por lo tanto, si el compilador rellena los ceros adicionales en el momento de la promoción, obtendríamos el mismo resultado en el equivalente decimal de los lados izquierdo y derecho en comparación (x == 0.5). 

Puede consultar Representación de punto flotante: conceptos básicos para la representación de números de punto flotante.

Este artículo es aportado por Abhay Rathi y mejorado por SHUBHAM BANSAL . Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.