|
CONVERSION AUTOMATICA DE TIPOS
Cuando dos ó mas tipos de variables distintas se
encuentran DENTRO de una misma operación ó expresión matemática , ocurre una
conversión automática del tipo de las variables. En todo momento de realizarse una
operación se aplica la siguiente secuencia de reglas de conversión (previamente a la
realización de dicha operación):
1) Las variables del tipo char ó short se
convierten en int
2) Las variables del tipo float se convierten en
double
3) Si alguno de los operandos es de mayor
precisión que los demás , estos se convierten al tipo de aquel y el resultado es del
mismo tipo.
4) Si no se aplica la regla anterior y un
operando es del tipo unsigned el otro se convierte en unsigned y el resultado es de este
tipo.
Las reglas 1 a 3 no presentan problemas, sólo
nos dicen que previamente a realizar alguna operación las variables son promovidas a su
instancia superior. Esto no implica que se haya cambiado la cantidad de memoria que las
aloja en forma permanente Otro tipo de regla se aplica para la conversión en las
asignaciones.
Si definimos los términos de una asignación
como,"lvalue" a la variable a la izquierda del signo igual y "rvalue"
a la expresión a la derecha del mismo, es decir:
"lvalue" = "rvalue" ;
Posteriormente al cálculo del resultado de
"rvalue" (de acuerdo con las reglas antes descriptas), el tipo de este se iguala
al del "lvalue". El resultado no se verá afectado si el tipo de
"lvalue" es igual ó superior al del "rvalue", en caso contrario se
efectuará un truncamiento ó redondeo, segun sea el caso.
Por ejemplo, el pasaje de float a int provoca el
truncamiento de la parte fraccionaria, en cambio de double a float se hace por redondeo.
ENCLAVAMIENTO DE CONVERSIONES (casting)
Las conversiones automáticas pueden ser
controladas a gusto por el programador, imponiendo el tipo de variable al resultado de una
operación. Supongamos por ejemplo tener:
double d , e , f = 2.33 ; int i = 6 ; e = f * i ;
d = (int) ( f * i ) ;
En la primer sentencia calculamos el valor del
producto (f * i) , que según lo visto anteriormente nos dará un double de valor 13.98 ,
el que se ha asignado a e. Si en la variable d quisiéramos reservar sólo el valor entero
de dicha operación bastará con anteponer, encerrado entre paréntesis, el tipo deseado.
Así en d se almacenará el número 13.00.
También es factible aplicar la fijación de tipo
a una variable, por ejemplo obtendremos el mismo resultado, si hacemos:
d = (int) f * i ;
En este caso hemos convertido a f en un entero
(truncando sus decimales )
VARIABLES DE TIPO CARACTER
El lenguaje C guarda los caracteres como números
de 8 bits de acuerdo a la norma ASCII extendida , que asigna a cada caracter un número
comprendido entre 0 y 255 ( un byte de 8 bits) Es común entonces que las variables que
vayan a alojar caracteres sean definidas como:
char c ;
Sin embargo, también funciona de manera correcta
definirla como
int c ;
Esta última opción desperdicia un poco más de
memoria que la anterior ,pero en algunos casos particulares presenta ciertas ventajas .
Pongamos por caso una función que lee un archivo de texto ubicado en un disco. Dicho
archivo puede tener cualquier caracter ASCII de valor comprendido entre 0 y 255. Para que
la función pueda avisarme que el archivo ha finalizado deberá enviar un número NO
comprendido entre 0 y 255 ( por lo general se usa el -1 , denominado EOF, fin de archivo
ó End Of File), en este caso dicho número no puede ser mantenido en una variable del
tipo char, ya que esta sólo puede guardar entre 0 y 255 si se la define unsigned ó no
podria mantener los caracteres comprendidos entre 128 y 255 si se la define signed . El
problema se obvia facilmente definiéndola como int.
Las variables del tipo caractér también pueden ser
inicializadas en su definición, por ejemplo es válido escribir:
char c = 97 ;
para que c contenga el valor ASCII de la letra
"a", sin embargo esto resulta algo engorroso , ya que obliga a recordar dichos
códigos . Existe una manera más directa de asignar un caractér a una variable ; la
siguiente inicialización es idéntica a la anterior :
char c = 'a' ;
Es decir que si delimitamos un caracter con
comilla simple , el compilador entenderá que debe suplantarlo por su correspondiente
código numérico.
Lamentablemente existen una serie de caracteres que
no son imprimibles , en otras palabras que cuando editemos nuestro programa fuente
(archivo de texto) nos resultará difícil de asignarlas a una variable ya que el editor
las toma como un COMANDO y no como un caracter. Un caso típico sería el de "nueva
linea" ó ENTER .
Con el fin de tener acceso a los mismos es que
aparecen ciertas secuencias de escape convencionales . Las mismas estan listadas en la
tabla y su uso es idéntico al de los caracteres normales , asi para resolver el caso de
una asignación de "nueva linea " se escribirá:
char c = '\n' ; /* secuencia de escape */
SECUENCIAS DE ESCAPE
TAMAÑO DE LAS VARIABLES
En muchos programas es necesario conocer el
tamaño (cantidad de bytes) que ocupa una variable, por ejemplo en el caso de querer
reservar memoria para un conjunto de ellas. Lamentablemente, como vimos anteriormente este
tamaño es dependiente del compilador que se use, lo que producirá, si definimos
rigidamente (con un número dado de bytes) el espacio requerido para almacenarlas, un
problema serio si luego se quiere compilar el programa con un compilador distinto del
original Para salvar este problema y mantener la portabilidad, es conveniente que cada vez
que haya que referirse al TAMAÑO en bytes de las variables, se lo haga mediante un
operador llamado "sizeof" que calcula sus requerimientos de almacenaje.
Está también permitido el uso de sizeof con un
tipo de variable, es decir:
sizeof(int) sizeof(char) sizeof(long double) ,
etc.
DEFINICION DE NUEVOS TIPOS
A veces resulta conveniente crear otros tipos de
variables , ó redefinir con otro nombre las existentes , esto se puede realizar mediante
la palabra clave "typedef" , por ejemplo:
typedef unsigned long double enorme ;
A partir de este momento ,las definiciones
siguientes tienen idéntico significado:
unsigned long double nombre_de_variable ; enorme
nombre_de_variable ;
CONSTANTES
Aquellos valores que , una vez compilado el
programa no pueden ser cambiados , como por ejemplo los valores literales que hemos usado
hasta ahora en las inicializaciones de las variables (1000 , 2 , 'a' , '\n' , etc), suelen
denominarse CONSTANTES .
Como dichas constantes son guardadas en memoria de
la manera que al compilador le resulta más eficiente suelen aparecer ciertos efectos
secundarios , a veces desconcertantes , ya que las mismas son afectadas por las reglas de
RECONVERSION AUTOMATICA DE TIPO vista previamente.
A fin de tener control sobre el tipo de las
constantes, se aplican la siguientes reglas :
Una variable expresada como entera (sin parte
decimal) es tomada como tal salvo que se la siga de las letras F ó L (mayúsculas ó
minúsculas) ejemplos :
1 : tomada como ENTERA
1F : tomada como FLOAT
1L : tomada como LONG DOUBLE
Una variable con parte decimal es tomada siempre
como DOUBLE, salvo que se la siga de la letra F ó L
1.0 : tomada como DOUBLE
1.0F : tomada como FLOAT
1.0L : tomada como LONG FLOAT
Si en cualquiera de los casos anteriores
agregamos la letra U ó u la constante queda calificada como UNSIGNED (consiguiendo mayor
alcance) :
1u : tomada como UNSIGNED INT
1.0UL : tomada como UNSIGNED LONG DOUBLE
Una variable numérica que comienza con
"0" es tomado como OCTAL asi : 012 equivale a 10 unidades decimales
Una variable numérica que comienza con
"0x" ó "0X" es tomada como hexadecimal : 0x16 equivale a 22 unidades
decimales y 0x1A a 26 unidades decimales.
CONSTANTES SIMBOLICAS
Por lo general es una mala práctica de
programación colocar en un programa constantes en forma literal (sobre todo si se usan
varias veces en el mismo) ya que el texto se hace dificil de comprender y aún más de
corregir, si se debe cambiar el valor de dichas constantes.
Se puede en cambio asignar un símbolo a cada
constante, y reemplazarla a lo largo del programa por el mismo, de forma que este sea más
legible y además, en caso de querer modificar el valor, bastará con cambiarlo en la
asignación.
El compilador, en el momento de crear el ejecutable,
reemplazará el símbolo por el valor asignado.
Para dar un símbolo a una constante bastará, en
cualquier lugar del programa (previo a su uso) poner la directiva: #define, por ejemplo:
#define VALOR_CONSTANTE 342
#define PI 3.1416
|
