Manual de Programación en C: Tipos de datos. Variables.


Recuerdo cuando veía la gente que aprendía programación oír hablar por primera vez de las variables, (esto fue en el colegio, cuando nos enseñaron LOGO, bastante inútil por cierto), yo ya había aprendido a programar por mi cuenta, y cuando nos hablaban de guardar datos o números bajo un nombre, la gente decía, ¿y para qué quiero yo guardar un número?

Para alguien que sepa de informática esta pregunta es bastante estúpida, ¿para qué quiero yo guardar algo en el ordenador? Sería una pregunta similar.

La respuesta es: para todo. Supongamos que hacemos un videojuego, ¿cuántas balas le quedan al protagonista? Pues creamos una variable y guardamos el número de balas dentro, cada vez que dispara le restamos 1 a la variable y ya
está, ¿cómo puedo saber si si está en un sitio? De la misma forma, creamos una variable en la que guardamos la posición. Espero que veáis para qué sirven las variables, no es muy difícil comprender su importancia.

Tipos de datos:

Es evidente que no todos los datos de un ordenador son iguales, habrá quien diga: ¿pero no eran todo unos y ceros? Pues sí, lo son, pero en programación abstraemos eso para que sea más sencillo, y creamos distintos tipos de variables según el dato que sea y la memoria que se use.

Podemos ver las variables como un cajón en el que guardar cosas, en cada cajón solo podemos guardar una cosa, y los cajones pueden ser de distinto tipo y de distinto tamaño.

 

NOTA: Recuerda que la memoria del ordenador funciona sobre
bits, que es la unidad más pequeña y que solo puede ser 1 o 0. 

1 byte = 8 bits, 1 byte puede ir desde 00000000 a 11111111,
para pasar de binario a decimal, multiplicamos de derecha a izquierda
por 2 elevado a la series de números naturales de 0 a donde lleguemos,
en este caso:

1·20 + 1·21 + 1·22 + 1·23
+ 1·24 + 1·25 + 1·26 + 1·27 =
255

De modo que en un byte podemos guardar números desde el 0
hasta el 255.

Para calcular el mayor número que podemos guardar en una
cantidad de bytes, elevamos 2 al número de bits, por ejemplo en 4 bytes
= 32 bits, podemos guardar hasta el número:

232 = 4294967296 → desde 0 hasta 4294967296

O hasta la mitad si contamos desde el menor negativo hasta el
mayor positivo.

 

 

Cuando creamos una variable le damos un nombre que usaremos para referirnos a ella dentro del programa, y le damos un tipo de dato, vamos a verlo con un ejemplo sobre el primer tipo de datos:

 

Tipo int → entero

El tipo int maneja números enteros, podemos guardar en este tipo de variables cualquier número entero entre un rango que depende de la memoria que ocupe el tipo int, que son 4 bytes.

 

Para crear una variable la declaramos, declarar una variable es decirle al sistema que nos reserve un hueco en la memoria para ella, y la declaramos escribiendo el tipo de dato y luego un nombre que nos inventemos, por ejemplo:

 

int variable;

De este modo creamos una variable de tipo int que se llama “variable”, y este nombre es el que usaremos para referirnos a ella en nuestro programa. ¿Cómo le damos un valor? Pues tan fácil como esto:

variable = 20;

Así la variable llamada variable tendrá guardado el número 20. No hace falta volver a poner int una vez creada, de hecho si lo pones el compilador interpretará que la quieres crear de nuevo y dará error, de modo que ponemos int solo la primera vez, cuando la declaramos.

 

Hay dos modos de declarar una variable, de modo local y de modo global, eso tiene que ver con funciones y no
lo veremos de momento, quédate con una variable es declarada como global si se crea fuera de la función main() y como local si se crea dentro, como no vamos a crear funciones de momento, crea las variables dentro de la función main(). Por ejemplo:

#include <stdio.h> 

int main(int argc, char *argv[])

{

int numero;

numero = 5;

 

return 0;

}

 

También se puede dar valor a una variable a la vez que se crea, de la siguiente manera:

int numero = 3; // Creamos una variable llamada numero y le
damos el valor 3.

Y declarar varias variables del mismo tipo en una sola linea si las separamos por comas.

int var1, var2; // Creamos dos variables 

int var3 = 5, var4 = -3; // Creamos otras dos variables y les
damos valores.

 

El nombre de la variable puede ser el que quieras, siempre y cuando no empiece por números y no tenga los símbolos / . y otros reservados. Yo recomiendo usar solo letras, números y barras bajas. Tampoco pueden tener espacios.

 

Tipo char

El tipo char (del inglés character) sirve para almacenar, como bien habrás deducido, caracteres.

Puede tener cualquier número del código ASCII, es decir, entre 0 y 255.

 

NOTA: El código ASCII le da un número entre 0 y 255 a cada
carácter imprimible. 

Puedes ver una tabla con los códigos ASCII de cada carácter
aquí.

 

Pero no necesitaremos saber el código para darle valor a una variable char. Estas variables, como todas, se
definen poniendo delante el tipo de dato y luego el nombre de la variable.

 

char caracter;

 

Le podemos dar valor de dos formas, o bien dándole el código ASCII del carácter, o bien dándole
directamente el carácter entre comillas simples.

 

char letra = ‘a’;

Es lo mismo que:

char letra = 97; // El 97 es el código ASCII de la letra a
minúscula.

 

Cada variable char puede contener un solo carácter.

 

Mostrar las variables.

Hemos conseguido hasta ahora crear variables y guardar datos en ellas, para imprimirlas por pantalla usaremos la ya conocida función printf, ¿recuerdas su estructura?

 

void printf(const char *format, …)

 

NOTA IMPORTANTE: Vemos que las funciones también tienen un
tipo de dato, en este caso void, el tipo de datos de una variable
indica que dato dará por salida, o que nos devolverá, por ejemplo, si
tenemos una función que nos suma dos números y nos devuelve la suma, su
forma podría ser así: 

int suma_numeros(int numero1, int numer2)

Ahora ya entendemos esto: los parámetros son numero1 y
numero2, que son de tipo int, de modo que cuando usemos esta variable
le deberemos pasar dos argumentos entre paréntesis de tipo int
(números), y nos dará otro dato de tipo int, que será la suma.

Luego veremos como aprovechar esto.

El tipo void, que en inglés significa vacío, es precisamente
eso, que no devuelve nada, ya que printf lo único que hace es sacar un
texto por la pantalla, no devuelve ningún tipo de dato.

Si recordáis la metáfora de la secretaria, si le pedimos por
ejemplo que llame a alguien no obtendremos nada, realizará la función,
pero no nos dará ningún dato de salida, será “void”.

 

Empezamos a entender el parámetro que nos pide: const char *format, un dato de tipo char, el asterisco indica que es un puntero, algo que veremos en próximos capítulos (y que hace C uno de los lenguajes más potentes), recuerda que una variable de tipo char solo puede guardar un carácter, con el * hacemos que pueda guardar una serie de caracteres.

 

Usemos la función printf para escribir el valor de una variable, haber si has entendido como crearlas: haz un programa, dentro de la función main declara una variable de tipo entero (int) llamada variable y dale el valor 3, a continuación pon:

 

printf(“El valor de la variable es: %i\n”, variable);

El código queda:

 

#include <stdio.h>

 

int main()

{

int variable
= 3;

printf(“El
valor de la variable es: %i”, variable);

 

return 0;

}

Ahora compila y ejecuta, en pantalla se mostrará el mensaje:

 

El valor de la variable es: 3

 

¿Qué hemos hecho? Lo único que vemos nuevo es que dentro de la cadena hay un símbolo %i

El símbolo % en una cadena y la letra siguiente indica que se va a incluir una variable y sustituirá el % y la letra siguiente, en este caso i de int, por el valor de la variable que le pasemos como segundo parámetro.

 

Para las variables de tipo char es igual solo que en vez de %i escribiremos %c, la c es de char.

 

Pues ahora haremos un programa que imprima una letra en pantalla. Prueba a hacerlo tú, deberías ser capaz, tan solo hay cambiar el tipo de variable a char, meterle como valor una letra entre comillas simples y cambiar el %i por %c en la
función printf().

Tamaño de las
variables en memoria.

Como he dicho al principio, cuando declaramos una variable le mandamos un mensaje la sistema para que nos reserve un espacio en la memoria RAM del ordenador para esa variable, y la cantidad de memoria que nos reservará dependerá del tipo de variable, hay una función que nos permite saber cuánto ocupa cada variable en bytes, lo que nos permite calcular su rango.

Esa función es sizeof, y su formato es el siguiente:

int sizeof(tipo_de_dato)

Ahora si entendemos lo que hace, su salida es de tipo int, eso es como si a la hora de ejecutar, la función se convirtiera en un número entero que dependerá del parámetro, que es tipo_de_dato, aquí podemos poner el tipo de dato directamente o una variable, calculará el número de bytes que ocupa esa variable:

sizeof(int);

Es lo mismo que:

int variable;

sizeof(variable);

 

Probemos a ver que nos da, los resultados que muestre aquí son los de mi ordenador, los tuyos pueden cambiar, ya que depende del ordenador que uses, (memoria y procesador) y del compilador.

 

#include <stdio.h> 

int main()

{

int dato;

int tamaño = sizeof(dato);

printf(“Tamaño de int:
%i\n”,tamaño);

return 0;

}

Como el tipo de salida de sizeof es int, creamos una variable llamada tamaño de tipo int y le damos el valor que nos devuelva sizeof, después la imprimimos con printf, habría dado lo mismo hacer esto directamente:

printf(“Tamaño de int: %i\n”, sizeof(int));

 

La salida del anterior en mi ordenador es:

 

Tamaño de int: 4

Eso significa que el tipo int puede almacenar 4 bytes de información, como 4 bytes = 4 · 8 bits = 32
bits, y 232 = 4.294.967.296, entonces ese es el número de valores distintos que puede tener una variable de tipo int, pero atención, no es el número máximo que puede guardar, porque int también puede guardar números negativos, de modo que el número máximo será la mitad, ya que puede guardar desde el -2.147.483.648 al +2.147.483.648.

 

Más variables.

Hemos visto los tipos principales de variables, pero hay más que veremos a continuación.

 

Tipo float.

Este tipo es float o coma flotante, eso quiere decir que podremos meterle números con decimales, no solo
enteros como anteriormente.

En float podemos guardar valores de -3.4·10-38 a 3.4·1038.

Pongo puntos en vez de comas porque el decimal debe especificarse así, cuidado que las comas darán error.

 

float variable = 456.23;

 

Tipo double

Esto es de doble coma flotante, podremos guardar números en el rango de -1.7·10-307 a 1.7·10308

 

double variable = 432.23435;

 

Para imprimir tanto el tipo double como el float con la función printf podemos usar el símbolo %d, de hecho, podemos usar ese para int, float y double.

 

double variable = 43.43; 

printf(“Valor de variable: %d\n”, variable);

 

Unsigned

Esto no es un tipo de dato, sino un modificador, esto quiere decir que cambiará el tipo de variable pero no es un tipo en si mismo, se puede asignar a cualquier tipo y lo que hace es quitarle el signo, por ejemplo, si le hacemos un sizeof a
char, veremos que ocupa 1 byte = 8 bits, 28 = 255, así que puede guardar 256 valores, entre -127 y 128, si definimos el char como unsigned, lo que hacemos es quitarle el signo, es decir podrá guardar valores entre 0 y 255.

 

Por ejemplo

unsigned int entero_sin_signo = 3000000000;

Ese valor estaría fuera del rango del tipo int, que llega a 2.147.483.648, pero al hacerlo de tipo unsigned, ya lo podemos guardar en la variable.

 

Overflow

El overflow es algo que pasa cuando nos pasamos del rango de la variable, en el caso anterior, si guardáramos ese número en una variable int sin el modificador unsigned, al compilar el compilador nos daría un aviso de que nos hemos pasado, no nos daría error, ya que lo que haría sería una vez se ha pasado, ir al mínimo valor y seguir sumando desde allí, por ejemplo:

 

#include <stdio.h> 

int main()

{

int entero_con_signo = 3000000000;

printf(“Valor: %i\n”,
entero_con_signo);

return 0;

}

Al compilar en Linux con gcc me da este aviso:

mostrar.c: In function ‘main’:

mostrar.c:5: warning: this decimal constant is unsigned
only in ISO C90

Me dice que no lo he definido como unsigned, osea que me he pasado.

El resultado es:

Valor: -1294967296

Se ha pasado y ha seguido sumando desde el menor. Este tipo de fallos se llaman fallos de overflow.

Constantes

Este es el último apartado de esta entrega.

Hasta ahora hemos visto variables, si nos vamos al significado de la palabra significa que varían, y efectivamente, durante el transcurso del programa podemos cambiar el valor de las variables de forma sencilla al que queramos. Podemos hacer:

int variable = 3; 

variable = 5;

Al definirla le hemos dado el valor 3 y luego le hemos dado el valor 5, osea que el 3 desaparece.

 

Operaciones muy básicas

También podemos hacer operaciones con ellas, aunque las veremos en el próximo capítulo más a fondo:

 

int variable = 3; 

variable = variable +1; // Variable vale 3, luego si ahora
vale variable +1, valdrá 3+1 = 4.

 

int var1 = 3, var2 = 4;

int var3 = var1 + var2; //var3
valdrá 3+4 = 7

 

NOTA: Signos básicos de operaciones 

+ sumar → var1 + var2;

– restar → var1 – var2;

* multiplicar → var1 * var2;

/ dividir → var1 / var2;

++ sumar uno → var1++;

– restar 1 → var1–;

 

A veces nos conviene definir variables cuyo valor no cambie durante el programa, serán constantes, estas se definen con #define al principio y su valor no puede cambiar.

 

#define Constante 5

Se definen así, #define, Luego un espacio y el nombre de la variable, en este caso Constante, luego un espacio y al final su valor, en este caso 5. No es obligatorio, pero es como una regla de buena presentación poner el valor de la variable después de un tabulado, no solo un espacio simple.

 

Vamos a ver el uso de constantes con un programa muy sencillo que hará algo tan simple como calcular la longitud de una circunferencia, que como deberías saber es 2xPIxradio. Con lo que hemos visto hasta ahora deberías ser capaz de
hacerlo, aunque aquí tienes el código:

 

 

#include <stdio.h> 

int main()

{

float radio = 5;

float pi = 3.1416;

float longitud = 2 * pi *
radio;

 

printf(“La longitud es de %d
cm\n”, longitud);

return 0;

}

 

Es un programa muy simple, no creo que haga falta comentarlo, ya que deberías entenderlo, si queremos calcular una longitud de una circunferencia de radio diferente, simplemente cambiamos el valor de la variable radio, sin embargo, el valor de la variable pi nunca cambiará, ya que es una constante matemática racional. Ahora veremos el mismo programa cambiando la variable pi por una constante, a la que llamaremos PI.

 

#include <stdio.h> 

#define PI 3.1416

int main()

{

float radio = 5;

float longitud = 2 * radio *
PI;

 

printf(“Longitud: %d\n”,
longitud);

 

return 0;

}

 

El programa hará lo mismo, pero ahora no corremos el riesgo de cambiar accidentalmente el valor, cosa que puede pasar en programas más complicados. Si recuerdas la primera entrega, en la que hablábamos del proceso de creación de un programa, en un momento de preprocesado decíamos que se sustituían los #define, esto que quiere decir, que cada vez que se llega a un #define, se ve su valor, se recorre el programa en busca de los lugares donde se utilice y se cambia, para borrar el define a continuación. El código quedaría así:

 

 

#include <stdio.h> 

int main()

{

float radio = 5;

float longitud = 2 * radio *
3.1416;

 

printf(“Longitud: %d\n”,
longitud);

 

return 0;

}

 

Hasta aquí este capítulo, para cualquier duda ver en blog la sección Contactos y enviarme un email o preguntar por aquí. Este capítulo puede ser muy denso si es la primea vez que se oye hablar de esto, así que tómate tu tiempo y prueba cosas, inventa programas simples que usen variables a ver qué has aprendido.

Licencia de Creative Commons
Manual de C by The Neowriter is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.

Anuncios
Esta entrada fue publicada en Manual de programación en C, Manuales, Manuales largos y etiquetada , , , , , , . Guarda el enlace permanente.

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s