Indice

Variables & Constantes..

Julio, 22, 2019 Chunche95

Definición de variables.

Si deseo 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;  /* Multiplicador como un entero */
    int multiplicando;  /* Multiplicando como un entero */
    int resultado;      /* Resultado como entero */
    multiplicador=1000; /* Asignación de valores */
    multiplicando = 2;
    resultado = multiplicando * multiplicador;
    printf("Resultado = %d\n", resultado) ; /* Muestro resultado */
    return 0;
}
                                    
                                

Resultado=2000

INICIALIZACIÓN DE VARIABLES.

Las variables del mismo tipo pueden definirse mediante una definiciónmúltiple separándolas mediante "," a saber:

int multiplicador, multiplicando, resultado;

int multiplicador=1000, multiplicando=2, resultado;

                                    
            
#include <stdio.h>
main()
{
    int multiplicador=1000, multiplicando=2;
    printf("Resultado: %d\n", multiplicando*multiplicador);
    return 0;
}
            
                                    
                                    

TIPOS DE VARAIBLES.

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" o maximo 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 en 0).
En caso de necesitar un rango más amplio, puede definirse la variable como "long int nombre_de_variable" o una 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 enlace menor al de int, podría definirse "short int" o "short", aunque por lo general, los compiladores modernos asignan a este tipo el mismo alcance que "int".
Para variables de muy pequelo valor puede usarse el tipo "char" cuyo alcance está restringido a -128 y 127 y por lo general ocupa un único byte.
Todos los tipos citados hast ahora pueden alojar valores positivos o 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 init
signed char

Variables de número real o punto flotante.

Un número real o de punto flotante es aquel que además de una parte entera, posee fracciones de unidad. En nuestra convención numérica solemos escribirlos de la siguiente manera: 2,87. Los compiladores usan en punto decimal, en vez de la coma, así el número Pi se escribirá: 3.14159.
La notación científica aceptada es: 2.4993E+02, equivalente a 2.4993*100 0 249.930
de acuerdo a su alcance hay tres tipos de variables de punto flotante, las mismas están descritas en la tabla 2.

Conversión automática de tipos.

Cuando dos o más tipos de variables distintas se encuentran dentro de una misma operación o 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 variables de tipo char o short se cinvierten en int.
• Las variables del tipo float se convierten en double.
• 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 de este tipo.
• Si no se aplica la regla anterior y un openrando es del tipo unsigned el otro se convierte en unsigned y el resultado es de este tipo.

"lvalue"="rvalue";

Enclavamiento de conversiones (casting).

Las conversiones automáticas pueden ser controladas a gusto por el programador, imponiendo el tipo de variables al resultado de una operación. Supongamos por ejemplo tener:

                                        
double d,e,f=1.23;
int i=6;
e=f*i;
d=(int)(f*i);
                                        
                                    

                                        
d = (int) f*i;
                                        
                                    

Variables de tipo carácter.

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;. Ésta 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 puede 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 o 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 define unsigned o no podría mantener los caracteres comprendidos entre 128 y 255 si se define signed (ver tabla 1). El problema se obvia fácilmente definiéndola como int.
Las variables del tipo carácter también pueden ser inicializadas en su definición, por ejemplo es válido escribir:

                                        
char c=97;
                                        
                                    

                                        
char c='a';
                                        
                                    

                                        
char c='\n'; /* secuencia de escape */
                                        
                                    

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 conjutno de ellas. El tamaño es dependiente del compilador que se use, lo que producirña, si definimos rigidamente (con un número dado de bytes) es espacio requerido para almacenarlas, un problema serio si luego se quiere compilar el programa con un compilador distinto del original.
Para salvar este programa 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.
                                        
                                    

Definición de nuevos tipos (typedef).

A veces resulta conveniente crear otros tipos de variables o redefinir con otro nombre las existentes, esto se puede realizar mediante la palabra clave 'typedef', por ejemplo:

                                        
typedef unsigned long double nomb_var ;
                                        
                                    

                                        
unsigned long double nombre_variable;
nomb_var  nombre_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 AUTOMÁTICA DE TIPO vista previamente.
A fin de tener control sobre el tipo de las constantes, se aplican las siguientes reglas:

• Una variable expresada como entera (sin parte decimal) es tomada como tal salvo que se siga con 'F' o 'L', ejemplos:

                                                  
  1: Entero
  1F: Float 
  1L: Long Double
                                                  
                                              

• Una variable con parte decimal es tomada siempre como DOUBLE, salvo que se siga con 'F' o 'L'.

                                                  
  1.0: Double 
  1.0F: Float 
  1.0L: Long Float
                                                  
                                              

• Si en cualquiera de los casos anteriores agregamos la leta 'U' o 'u', la constante queda definida como UNSIGNED (consiguiendo mayor alcance).

                                                  
  1.0UL: Unsigned Int
                                                  
                                              

• Una variable numérica que comienza con '0' es de tipo Octal, entonces : 012 equivale a 10 unidades decimales.
• Una variable numérica que comienza con '0x' o '0X' es tomada como hexadecimal.

                                                  
   Hex    Dec 
  0x16 = 22
  0X1A = 26 
                                                  
                                              

Constantes simbólicas

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 difícil 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, 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 problema ( previo a su uso) poner la directiva:
#define
Por ejemplo:

                                        
#define valor_constante 300
#define PI 3.1415926