¿Por qué la división resulta en cero en lugar de decimal?

Me doy a mí mismo C y descubro que cuando hago una ecuación para una conversión temporal, no funcionará a menos que cambie la fracción a un decimal. es decir,

tempC=(.555*(tempF-32)) funcionará, pero tempC=((5/9)*(tempF-32)) no funcionará.

¿Por qué?
De acuerdo con C Primer Plus debería funcionar ya que estoy usando flotadores para tempC y tempF.

Parece que tienes división entera en el segundo caso:

 tempC=((5/9)*(tempF-32)) 

El 5 / 9 se truncará a cero.

Para solucionarlo, debes hacer que uno de ellos sea de tipo flotante:

 tempC=((5./9.)*(tempF-32)) 

Otros ya te han dicho, 5 y 9 son enteros y es por eso que el resultado se trunca.

Añadiré una explicación para una comprensión más profunda de lo que realmente sucede entre líneas:

 double tempC; double tempF; tempC = (5/9) * (tempF-32); // removed unnecessary parenthesis 

Dependiendo del orden de evaluación , de izquierda a derecha o de derecha a izquierda, que use el comstackdor específico, comenzará la evaluación de la (tempF-32) (5/9) o (tempF-32) .

¡No puedes saber cuál de estos dos se evalúa primero! Porque el orden de evaluación es un comportamiento no especificado en C, lo que significa que el comstackdor puede hacerlo de cualquier manera sin documentar cómo. Por lo tanto, nunca se debe escribir un código que dependa del orden de evaluación, o no será portátil y posiblemente incorrecto.


Supongamos que un comstackdor específico usa evaluación de izquierda a derecha.

  • Las reglas de precedencia del operador de C deciden dónde comienza la evaluación. El operador de paréntesis tiene la prioridad más alta en C, por lo que el comstackdor comenzará evaluando el contenido del primer paréntesis encontrado.
  • Por lo tanto, comenzará con la expresión (5/9) .
  • El comstackdor verifica el tipo de cada operando.
  • En este caso, ambos son literales enteros constantes. Los literales enteros siempre son del tipo int en C.
  • Como ambos operandos son del mismo tipo, no se necesitan conversiones de tipo implícitas.
  • El cálculo se realiza en un tipo int y el resultado es un int .

Entonces ahora la expresión ahora se evalúa para:

tempC = (int)0 * (tempF-32);

  • El comstackdor luego evalúa (tempF-32).
  • Los tipos de operandos son double e int . No son del mismo tipo.
  • Se producen conversiones de tipo implícito. En este caso, algo llamado balanceo (formalmente llamado las conversiones aritméticas usuales ).
  • Las reglas de equilibrio dicen que si un tipo es doble y el otro es algo diferente, el otro tipo debe convertirse a doble.
  • Después de la conversión de tipo implícita, la expresión ahora es equivalente a (double)tempF - (double)32.0 . El resultado de esto se calcula y almacena en una variable temporal e invisible de tipo double . Esta variable invisible se almacena en un registro de CPU o en la stack.

Ahora la expresión se puede describir como

tempC = (int)result1 * (double)result2;

donde “resultado1” es 0 y “resultado2” es el resultado de tempF – 32.0.

  • El comstackdor luego evalúa esta nueva expresión. Encuentra un int y un double .
  • De nuevo, se produce el equilibrio y el int se convierte en un doble.
  • La multiplicación se realiza en dos dobles, y el resultado es un doble.
  • El resultado se almacena en otra variable temporal e invisible.

tempC = (double)result3;

  • El comstackdor evalúa esta nueva expresión. Encuentra que un doble debe guardarse dentro de un doble. Eso no es un problema, por lo que no se necesitan conversiones implícitas. “result3” se almacena en tempC.

Cuando haces 5/9, 5 y 9 son ambos enteros y ocurre una división entera . El resultado de la división entera es un número entero y es el cociente de los dos operandos. Entonces, el cociente en el caso de 5/9 es 0 y dado que se multiplica por 0, el valor de tempC es 0. Para no tener una división entera, al menos uno de los dos operandos debe estar float .

Por ejemplo, si usa 5.0 / 9 o 5 / 9.0 o 5.0 / 9.0, funcionará como se esperaba.

5/9 es una división entera, no una división de coma flotante. Es por eso que estás obteniendo resultados incorrectos.

Haga 5 o 9 puntos flotantes variables y obtendrá la respuesta correcta.

Me gusta 5.0 / 9 OR 5 / 9.0

5/9 es una expresión entera, como tal, se trunca a 0. tu comstackdor debería advertirte sobre esto, de lo contrario, deberías buscar habilitar advertencias.

Si coloca 5/9 entre paréntesis, esto se calculará primero, y dado que esos son dos enteros, se hará por división entera y el resultado será 0, antes de que se evalúe el rest de la expresión.

Puede reorganizar su expresión para que la conversión a flotación ocurra primero:

tempC=((5/9)*(tempF-32));tempC=(5*(tempF-32))/9;

o, por supuesto, como dicen los demás, usa constantes de punto flotante.