Conversión entre tipos y operador cast

Conversión automática

C permite convertir de forma automática valores de distinto tipo numérico (incluidos los punteros). Las conversiones automáticas funcionan correctamente si se realizan desde un tipo con un rango de valores que se encuentre dentro del rango del receptor; no se garantiza el resultado en los demás casos.
Si se producen problemas en la conversión no se generarán errores en tiempo de ejecución, siendo el programador el responsable de que la ejecución de la conversión sea la correcta.

Conversiones automáticas en expresiones

Siempre que un operador se aplique sobre operandos de distinto tipo se realizará una conversión desde el de menor al de mayor rango. El resultado de la expresión tiene como tipo el de mayor rango.

Ejemplo

En la función main se utilizan conversiones automáticas entre distintos tipos de datos numéricos, indicando si pueden existir problemas o no. Además, se comenta la evaluación de expresiones.

#include <stdio.h>
int main(){
   int i, j, s1;           /* Enteros */
   char c;                 /* Carácter */
   long y;                 /* Puede omitirse el int */
   double x, z;            /* Variables reales de doble precisión */
   ...                     /* Se asignan valores a las variables */
   y = i;                  /* Conversión de valor int a long int nunca existe problema*/
   c = i;                  /* Conversión de valor int a char puede haber problemas */
   i = x;                  /* Conversión de valor double a int puede haber problemas*/
   x = j / s1;             /* Al ser los dos operandos de tipo entero la división será entera */
   printf("x=%lf \n", x);  /* El resultado aunque es de tipo double no tiene decimales */
   x = z / s1;             /* Al ser uno de los operandos real la división será de tipo real */
   printf("x=%lf \n", x);
   return 0;
}

Operador cast

Para realizar una conversión manual de valores se emplea el operador de conversión, en inglés "cast", molde.

Sintaxis

(tipo) expresión_a_convertir

Entre paréntesis se escribe el tipo al que se quiere convertir y a continuación la expresión cuyo resultado se va a convertir a ese tipo.

Decimales en la división de enteros

Si no se tienen en cuenta los mecanismos de conversión en la evaluación de expresiones, se obtienen resultados que no son del tipo esperado. El caso más común se da al dividir dos datos enteros, asignarlos a un real y esperar obtener resultados con decimales. Para obtener decimales en una división de dos enteros hay que convertir el valor de uno de los operandos en real para que la división cambie a una operación entre reales.

Ejemplo

En la función main se muestran varias formas de obtener decimales en una división entre enteros, algunas incluyen el uso del operador cast.

#include <stdio.h>
int main(){
   int i=1, s1=2;  /* Enteros */
   double x;       /* Variable real de doble precisión */
   x = i / 3;      /* El compilador evalúa la expresión con los tipos: (double) x = (int)((int) i / (int) 3); */
   printf("x=%lf \n", x);  /* El resultado aunque es de tipo double no tiene decimales */
   /* La expresión correcta sería */
   x = i / 3.;              /* Al ser 3. real la división será de tipo real */
   printf("x=%lf \n", x);
   /* O bien */
   x = ((double) i) / 3;    /* Al convertir el valor de i a real la división será de tipo real */
   printf("x=%lf \n", x);
   x = ((double) i) / s1;   /* Al convertir el valor de i a real la división será de tipo real */
   printf("x=%lf \n", x);
   return 0;
}

Conversión entre los nuevos tipos de C99

Cuando un valor real se convierte a un tipo complejo la parte real del número complejo se determina según la regla de conversión que se ha visto previamente, la parte imaginaria toma el valor 0.
Cuando un valor de tipo complejo se convierte a un número real, se descarta la parte imaginaria del valor complejo y la parte real se convierte de acuerdo a la regla de conversión.