Castings

Castings

Ya hemos visto como el compilador maneja las operaciones aritméticas cuando le pasamos una instrucción que indique realizar dicha tarea. También hablamos sobre lo que sucede cuando mezclamos diferentes tipos de variables: char, int, long. Vimos cuales pueden ser las combinaciones y los diferentes resultados que se pueden obtener.

El lenguaje C tiene un artilugio que nos permite forzar al compilador a que interprete un tipo de variable, sin importar que tipo de variable sea, que tome esa variable como si fuera de otro tipo. Esto nos permite explicitarle al compilador de que manera queremos que procese por ejemplo una operación aritmética, y cuando veamos más adelante las operaciones lógicas, también sirven.

Por ejemplo, si tenemos un programa hecho como se muestra a continuación:

unsigned char A;

unsigned int B;

unsigned int C;

A=0xFF;

B=0x3210;

C = A + B;

Hasta ahora, como habíamos dicho, la variable A se va a convertir en una variable temporal de 16 bits, a la misma se le va a cargar el valor positivo 255 (0xFF) ya que la variable A estaba declarada explícitamente como unsigned char . El resultado va a ser C=0x00FF + 0x3210 = 0x330F

Bien, pero en C, es posible hacer lo siguiente:

C = (signed char)A + B;

Colocando la línea con la operación aritmética de ésa manera, le indico al compilador, que si bien la variable A está declarada como unsigned char, le digo que al momento de crear la variable temporal de 16 bits, tome el valor como si la variable A fuera con signo, entonces, leerá la variable A como -1 y no como 255. El resultado va a ser entonces:  C = 0xFFFF + 0x3210 = 0x320F

O sea, en el primer caso sumó 255 a la variable B, y en el segundo caso, restó 1 al valor de la variable B.

También puedo armar la operación aritmética como:

C =(signed char)A+(signed char)B

Ahora, le digo al compilador que fuerce el valor de la variable A a ser una variable con signo de 8 bits. Como el resultado se almacenará en una variable de 16 bits, que es la variable C. El valor temporal que tomará la variable A será -1 y en 16 bits, o sea 0xFFFF. Y a la variable B le estoy indicando al compilador que la tome como una variable de 8 bits. Como el valor original de la variable B era 0x3210 pero la estoy forzando a que se interprete como una variable de 8 bits, entonces el compilador tomará para la variable temporal de 16 bits que utilizará para el cálculo,  el valor truncando el byte  más significativo. Esto es la operación que se ejecutará será: C = 0xFFFF + 0x0010 = 0x000F

Vemos que tenemos una herramienta interesante para forzar al microcontrolador que haga exactamente lo que nosotros le solicitamos hacer. También vemos la diferencia importante que hay cuando no están correctamente declarados o colocados los tipos de datos. Con el mismo programa, los mismos valores de datos, pero con variables diferentemente declaradas o forzadas, se producen resultados diferentes.

Ese forzamiento de un tipo de variable, para que sea tomado como otro tipo de variables, es lo que se denomina en C casting, o cast.

El casting es muy utilizado en los programas hechos en C, especialmente cuando se trata de programas largos, donde queremos explicitar el tipo de datos que necesitamos que tome el microcontrolador antes de procesar una operación aritmética, lógica, o cuando veamos más adelante llamados de funciones y otras tareas.