	Sign In Sign-Up

Curso de C++ (Página 10)

CAPITULO 10 Conversión de tipos

Quizás te hayas preguntado qué pasa cuando escribimos expresiones numéricas en las que todos los operandos no son del mismo tipo. Por ejemplo:

char n;
int a, b, c, d; 
float r, s, t; 
... 
a = 10; 
b = 100; 
r = 1000; 
c = a + b; 
s = r + a; 
d = r + b; 
d = n + a + r; 
t = r + a - s + c;
...

En estos casos, cuando los operandos de cada operación binaria asociados a un operador son de distinto tipo, se convierten a un tipo común. Existen reglas que rigen estas conversiones, y aunque pueden cambiar ligeramente de un compilador a otro, en general serán más o menos así:

Cualquier tipo entero pequeño como char o short es convertido a int o unsigned int. En este punto cualquier pareja de operandos será int (con o sin signo), double, float o long double.
Si algún operando es de tipo long double, el otro se convertirá a long double.
Si algún operando es de tipo double, el otro se convertirá a double.
Si algún operando es de tipo float, el otro se convertirá a float.
Si algún operando es de tipo unsigned long, el otro se convertirá a unsigned long.
Si algún operando es de tipo long, el otro se convertirá a long.
Si algún operando es de tipo unsigned int, el otro se convertirá a unsigned int.
En este caso ambos operandos son int.

Veamos ahora el ejemplo:

c = a + b; caso 8, ambas son int.

s = r + a; caso 4, "a" se convierte a float.

d = r + b; caso 4, "b" se convierte a float.

d = n + a + r; caso 1, "n" se convierte a int, caso 4 el resultado (n+a) se convierte a float.

t = r + a - s + c; caso 4, "a" se convierte a float, caso 4 (r+a) y "s" son float, caso 4, "c" se convierte a float.

También se aplica conversión de tipos en las asignaciones, cuando la variable receptora es de distinto tipo que el resultado de la expresión de la derecha.

Cuando esta conversión no implica pérdida de precisión, se aplican las mismas reglas que para los operandos, estas conversiones se conocen también como promoción de tipos. Cuando hay pérdida de precisión, las conversiones se conocen como democión de tipos. El compilador normalmente emite un aviso o "warning", cuando se hace una democión implícita, es decir cuando hay una democión automática.

En el caso de los ejemplos 3 y 4, es eso precisamente lo que ocurre, ya que estamos asignando expresiones de tipo float a variables de tipo int.

"Casting", conversiones explícitas de tipo:

Para eludir estos avisos del compilador se usa el "casting", o conversión explícita.

En general, el uso de "casting" es obligatorio cuando se hacen asignaciones, o cuando se pasan argumentos a funciones con pérdida de precisión. En el caso de los argumentos pasados a funciones es también muy recomendable aunque no haya pérdida de precisión. Eliminar los avisos del compilador demostrará que sabemos lo que hacemos con nuestras variables, aún cuando estemos haciendo conversiones de tipo extrañas.

Un "casting" tiene una de las siguientes formas:

(<nombre de tipo>)<expresión>

<nombre de tipo>(<expresión>)

Esta última es conocida como notación funcional.

En el ejemplo anterior, las líneas 3 y 4 quedarían:

d = (int)(r + b);
d = (int)(n + a + r);

ó:

d = int(r + b);
d = int(n + a + r);

Hacer un "casting" indica que sabemos que el resultado de estas operaciones no es un int, que la variable receptora sí lo es, y que lo que hacemos lo hacemos a propósito. Veremos más adelante, cuando hablemos de punteros, más situaciones donde también es obligatorio el uso de "casting".