1. DEFINICION DE VARIABLES
Si yo deseara imprimir los resultados de multiplicar un número fijo por
otro que adopta valores entre 0 y 9 , la forma normal de programar esto sería
crear una CONSTANTE para el primer número y un par de VARIABLES para
el segundo y para el resultado del producto. Una variable , en realidad , no
es más que un nombre para identificar una (o varias) posiciones de memoria
donde el programa guarda los distintos valores de una misma entidad . Un programa
debe DEFINIR a todas las variables que utilizará , antes de comenzar
a usarlas , a fin de indicarle al compilador de que tipo serán , y por
lo tanto cuanta memoria debe destinar para albergar a cada una de ellas. Veamos
el EJEMPLO 2:
EJEMPLO 2
#include <stdio.h> main() { int multiplicador; /* defino multiplicador como un entero */ int multiplicando; /* defino multiplicando como un entero */ int resultado; /* defino resultado como un entero */ multiplicador = 1000 ; /* les asigno valores */ multiplicando = 2 ; resultado = multiplicando * multiplicador ; printf("Resultado = %d\n", resultado); /* muestro el resultado */ return 0; }
En las primeras líneas de texto dentro de main() defino mis variables como números enteros , es decir del tipo "int" seguido de un identificador (nombre) de la misma . Este identificador puede tener la cantidad de caracteres que se desee , sin embargo de acuerdo al Compilador que se use , este tomará como significantes sólo los primeros n de ellos ; siendo por lo general n igual a 32 . Es conveniente darle a los identificadores de las variables , nombres que tengan un significado que luego permita una fácil lectura del programa. Los identificadores deben comenzar con una letra ó con el símbolo de subrayado "_" , pudiendo continuar con cualquier otro caractér alfanumérico ó el símbolo "_" . El único símbolo no alfanumérico aceptado en un nombre es el "_" . El lenguaje C es sensible al tipo de letra usado ; así tomará como variables distintas a una llamada "variable" , de otra escrita como "VARIABLE". Es una convención entre los programadores de C escribir los nombres de las variables y las funciones con minúsculas, reservando las mayúsculas para las constantes.
El compilador dará como error de "Definición incorrecta" a la definición de variables con nombres del tipo de :
4pesos $variable primer-variable !variable etc.etc
NOTA: Los compiladores reservan determinados términos ó palabras claves (Keywords) para el uso sintáctico del lenguaje, tales como: asm, auto, break, case, char, do, for, etc. Si bien estas palabras están definidas para el ANSI C, los distintos compiladores extienden esta definición a OTROS términos, por lo que es aconsejable leer la tabla completa de palabras reservadas del compilador que se vaya a usar, para no utilizarlas en nombres de variables. |
Vemos en las dos lineas subsiguientes a la definición de las variables, que puedo ya asignarles valores (1000 y 2) y luego efectuar el cálculo de la variable "resultado". Si prestamos ahora atención a la función printf(), ésta nos mostrará la forma de visualizar el valor de una variable. Insertada en el texto a mostrar, aparece una secuencia de control de impresión "%d" que indica, que en el lugar que ella ocupa, deberá ponerse el contenido de la variable ( que aparece luego de cerradas las comillas que marcan la finalización del texto , y separada del mismo por una coma) expresado como un un número entero decimal. Así, si compilamos y corremos el programa , obtendremos una salida :
SALIDA DEL EJEMPLO 2 Resultado = 2000
2. INICIALIZACION DE VARIABLES
Las variables del mismo tipo pueden definirse mediante una definición
múltiple separandolas mediante " , " a saber :
int multiplicador, multiplicando, resultado;
Esta sentencia es equivalente a las tres definiciones separadas en el ejemplo anterior. Las variables pueden también ser inicializadas en el momento de definirse .
int multiplicador = 1000, multiplicando = 2, resultado;
De esta manera el EJEMPLO 2 podría escribirse:
EJEMPLO 2 BIS
#include <stdio.h> main() { int multiplicador=1000 , multiplicando=2 ; printf("Resultado = %d\n", multiplicando * multiplicador); return 0; }
Obsérvese que en la primer sentencia se definen e inicializan simultaneamente ambas variables.La variable "resultado" la hemos hecho desaparecer ya que es innecesaria. Si analizamos la función printf() vemos que se ha reemplazado "resultado" por la operación entre las otras dos variables. Esta es una de las particularidades del lenguaje C : en los parámetros pasados a las funciones pueden ponerse operaciones (incluso llamadas a otras funciones) , las que se realizan ANTES de ejecutarse la función , pasando finalmente a esta el valor resultante de las mismas. El EJEMPLO 2 funciona exactamente igual que antes pero su código ahora es mucho más compacto y claro.
3. TIPOS DE VARIABLES
VARIABLES DEL TIPO ENTERO
En el ejemplo anterior definimos a las variables como enteros (int).
De acuerdo a la cantidad de bytes que reserve el compilador para este tipo de
variable, queda determinado el "alcance" ó máximo valor
que puede adoptar la misma.
Debido a que el tipo int ocupa dos bytes su alcance queda restringido al rango
entre -32.768 y +32.767 (incluyendo 0 ).
En caso de necesitar un rango más amplio, puede definirse la variable
como "long int nombre_de_variable" ó en forma más abreviada
"long nombre_de_variable"
Declarada de esta manera, nombre_de_variable puede alcanzar valores entre -
2.347.483.648 y +2.347.483.647.
A la inversa, si se quisiera un alcance menor al de int, podría definirse
"short int " ó simplemente "short", aunque por lo
general, los compiladores modernos asignan a este tipo el mismo alcance que
"int".
Debido a que la norma ANSI C no establece taxativamente la cantidad de bytes
que ocupa cada tipo de variable, sino tan sólo que un "long"
no ocupe menos memoria que un "int" y este no ocupe menos que un "short",los
alcances de los mismos pueden variar de compilador en compilador , por lo que
sugerimos que confirme los valores dados en este parágrafo (correspondientes
al compilador de Borland C++) con los otorgados por su compilador favorito.
Para variables de muy pequeño valor puede usarse el tipo "char"
cuyo alcance está restringido a -128, +127 y por lo general ocupa un
único byte.
Todos los tipos citados hasta ahora pueden alojar valores positivos ó
negativos y, aunque es redundante, esto puede explicitarse agregando el calificador
"signed" delante; por ejemplo:
signed int signed long signed long int signed short signed short int signed char
Si en cambio, tenemos una variable que sólo puede adoptar valores positivos (como por ejemplo la edad de una persona ) podemos aumentar el alcance de cualquiera de los tipos , restringiéndolos a que sólo representen valores sin signo por medio del calificador "unsigned" . En la TABLA 1 se resume los alcances de distintos tipos de variables enteras
TABLA 1 VARIABLES DEL TIPO NUMERO ENTERO
TIPO |
BYTES |
VALOR MINIMO |
VALOR MAXIMO |
signed char |
1 |
-128 |
127 |
unsigned char |
1 |
0 |
255 |
unsigned short |
2 |
-32.768 |
+32.767 |
unsigned short |
2 |
0 |
+65.535 |
signed int |
2 |
-32.768 |
+32.767 |
unsigned int |
2 |
0 |
+65.535 |
signed long |
4 |
-2.147.483.648 |
+2.147.483.647 |
unsigned long |
4 |
0 |
+4.294.967.295 |
NOTA: Si se omite el calificador delante del tipo de la variable entera, éste se adopta por omisión (default) como "signed". |
VARIABLES DE NUMERO REAL O PUNTO FLOTANTE
Un número real ó de punto flotante es aquel que además
de una parte entera, posee fracciones de la unidad. En nuestra convención
numérica solemos escribirlos de la siguiente manera : 2,3456, lamentablemente
los compiladores usan la convención del PUNTO decimal (en vez de la coma)
. Así el numero Pi se escribirá : 3.14159 Otro formato de escritura,
normalmente aceptado, es la notación científica. Por ejemplo podrá
escribirse 2.345E+02, equivalente a 2.345 * 100 ó 234.5
De acuerdo a su alcance hay tres tipos de variables de punto flotante , las
mismas están descriptas en la TABLA 2
TABLA 2 TIPOS DE VARIABLES DE PUNTO FLOTANTE
TIPO |
BYTES |
VALOR MINIMO |
VALOR MAXIMO |
float |
4 |
3.4E-38 |
3.4E+38 |
double |
8 |
1.7E-308 |
1.7E+308 |
long double |
10 |
3.4E-4932 |
3.4E+4932 |
Las variables de punto flotante son SIEMPRE con signo, y en el caso que el exponente sea positivo puede obviarse el signo del mismo.
5. 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):
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.
5. 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 )
6. 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 (ver TABLA 1). 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 3 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 */
TABLA 3 SECUENCIAS DE ESCAPE
CODIGO |
SIGNIFICADO |
VALOR ASCII |
VALOR ASCII |
'\n' |
nueva línea |
10 |
0x0A |
'\r' |
retorno de carro |
13 |
0x0D |
'\f' |
nueva página |
2 |
x0C |
'\t' |
tabulador horizontal |
9 |
0x09 |
'\b' |
retroceso (backspace) |
8 |
0x08 |
'\'' |
comilla simple |
39 |
0x27 |
'\"' |
comillas |
4 |
0x22 |
'\\ ' |
barra |
92 |
0x5C |
'\? ' |
interrogación |
63 |
0x3F |
'\nnn' |
cualquier caracter (donde nnn es el código ASCII expresado en octal) |
||
'\xnn' |
cualquier caracter (donde nn es el código ASCII expresado en hexadecimal) |
7. TAMAÑO DE LAS VARIABLES (sizeof)
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.
8. DEFINICION DE NUEVOS TIPOS ( typedef )
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 ;
9. 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 :
10. 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
|
|
|