Conversión de tipos (casting)
a) Casting Implícito:
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í:
1. 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.
2. Si algún operando es de tipo long double, el otro se convertirá a long double.
3. Si algún operando es de tipo double, el otro se convertirá a double.
4. Si algún operando es de tipo float, el otro se convertirá a float.
5. Si algún operando es de tipo unsigned long, el otro se convertirá a unsigned
long.
6. Si algún operando es de tipo long, el otro se convertirá a long.
7. Si algún operando es de tipo unsigned int, el otro se convertirá a unsigned int.
8. 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 realiza 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
conversión implícita, es decir cuando hay una conversió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.
b) Casting explícito:
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.
Editado por [email protected]
http://programandoenc.webcindario.com
0
