AnteriorPosterior

Tema 2: Introducción a las variables.

  Curso: Curso de Pascal, por Nacho Cabanes

Tema 2: Introducción a las variables.

Las variables son algo que no contiene un valor predeterminado, una posición de memoria a la que nosotros asignamos un nombre y en la que podremos almacenar datos.

En el primer ejemplo que vimos, puede que no nos interese escribir siempre el mensaje "Hola", sino uno más personalizado según quien ejecute el programa. Podríamos preguntar su nombre al usuario, guardarlo en una variable y después escribirlo a continuación de la palabra "Hola", con lo que el programa quedaría


program Saludo2;

var
nombre:
string[20];

begin
writeln(
'Introduce tu nombre, por favor');
readln(nombre);
write(
'Hola ',nombre);
end.



Aquí ya aparecen más conceptos nuevos. En primer lugar, hemos definido una variable, para lo que empleamos la palabra var, seguida del nombre que vamos a dar a la variable, y del tipo de datos que va a almacenar esa variable.

Los nombres de las variables siguen las reglas que ya habíamos mencionado para los identificadores en general, y no se indica ningún punto y coma entre la palabra "var" y el nombre de la variable (o variables que se declaran)..

Con la palabra string decimos que la variable nombre va a contener una cadena de caracteres (letras o números). Un poco más adelante, en esta misma lección, comentamos los principales tipos de datos que vamos a manejar. En concreto, string[20] indica que el nombre podrá estar formado hasta por 20 letras o números

Nota: en la variante del lenguaje Pascal conocida como "Extended Pascal", la longitud máxima de una cadena de texto se indica con paréntesis, de modo que si algún compilador protesta con "string[20]", habrá que probar con "string(20)".

Pasemos al cuerpo del programa. En él comenzamos escribiendo un mensaje de aviso. Esta vez se ha empleado writeln, que es exactamente igual que write con la única diferencia de que después de visualizar el mensaje, el cursor (la posición en la que se seguiría escribiendo, marcada normalmente por una rayita o un cuadrado que parpadea) pasa a la línea siguiente, en vez de quedarse justo después del mensaje escrito.

Después se espera a que el usuario introduzca su nombre, que le asignamos a la variable "nombre", es decir, lo guardamos en una posición de memoria cualquiera, que el compilador ha reservado para nosotros, y que nosotros no necesitamos conocer (no nos hace falta saber que está en la posición 7245 de la memoria, por ejemplo) porque siempre nos referiremos a ella llamándola "nombre". De todo esto se encarga la orden readln.

Si queremos dar un valor a la variable nosotros mismos, desde el programa, usaremos la expresión := (un símbolos de "dos puntos" y otro de "igual", seguidos, sin espacios entre medias), así:

Edad := 17;


Finalmente, aparece en pantalla la palabra "Hola" seguida por el nombre que se ha introducido. Como se ve en el ejemplo, "writeln" puede escribir varios datos, si los separamos entre comas, pero eso lo estudiaremos con detalle un poco más adelante...

Sólo un comentario antes de seguir: lo que escribimos entre comillas en una orden "write" aparecerá tal cual en pantalla; lo que escribimos sin pantalla, es para que el ordenador intente adivinar su valor. Así, se nos pueden dar casos como estos:

write ( 'Hola' ) Escribe Hola
write ( nombre ) Escribe el valor de la variable nombre
write ( '3+3' ) Escribe el texto 3+3
write ( 3+3 ) Escribe el resultado de la operación 3+3 (6)

Está claro que + es el símbolo que usaremos para sumar. Para restar emplearemos -, para multiplicar * y para dividir /. Más adelante veremos más detalles sobre las operaciones aritméticas.


Tema 2.2: Tipos básicos de datos.

En Pascal debemos declarar las variables que vamos a usar, avisar a nuestro compilador para que les reserve espacio. Esto puede parecer incómodo para quien ya haya trabajado en lenguaje Basic, pero en la práctica ayuda a conseguir programas más legibles y más fáciles de corregir o ampliar. Además, evita los errores que puedan surgir al emplear variables incorrectas: si queremos usar "nombre" pero escribimos "nombe", la mayoría de las versiones del lenguaje Basic no indicarían un error, sino que considerarían que se trata de una variable nueva, que no tendría ningún valor, y normalmente se le asignaría un valor de 0 o de un texto vacío.

En Pascal disponemos de una serie de tipos predefinidos, y de otros que podemos crear nosotros para ampliar el lenguaje. Los primeros tipos que veremos son los siguientes:

  • Integer. Es un número entero (sin cifras decimales) con signo, que puede valer desde -32768 hasta 32767. Ocupa 2 bytes de memoria. (Nota: el espacio ocupado y los valores que puede almacenar son valores para Turbo Pascal, y pueden variar para otros compiladores).
Ejercicio propuesto: Crea un programa que, en lugar de preguntarte tu nombre, te pregunte tu edad y luego la escriba en pantalla.
  • Byte. Es un número entero, que puede valer entre 0 y 255. El espacio que ocupa en memoria es el de 1 byte, como su propio nombre indica. (Nota: es un tipo de datos definido por Turbo Pascal, y puede no estar disponible en otros compiladores, como es el caso de GNU Pascal).
    Ejercicio propuesto: Crea un programa que te pregunte dos números del 1 al 10 y escriba su suma.
  • Char. Representa a un carácter (letra, número o símbolo). Ocupa 1 byte.

  • Ejercicio propuesto: Crea un programa que te pregunte tres letras y luego las escriba en orden inverso.

  • String. Es una cadena de caracteres, empleado para almacenar y representar mensajes de más de una letra (hasta 255). Ocupa 256 bytes. El formato en Pascal estándar (y en Turbo Pascal, hasta la versión 3.01) era string[n] (o string(n), según casos, como ya se han comentado), donde n es la anchura máxima que queremos almacenar en esa cadena de caracteres (de 0 a 255), y entonces ocupará n+1 bytes en memoria. En las últimas versiones de Turbo Pascal (y otros) podemos usar el formato "string[n]" o simplemente "string", que equivale a "string[255]". En otros compiladores, como GNU Pascal, el tamaño permitido es mucho mayor (normalmente por encima de las 32.000 letras).
Ejercicio propuesto: Crea un programa que te pida tres palabras y las muestre separadas por espacios y en el orden contrario a como las has introducido (primero la tercera palabra, después la segunda y finalmente la primera).
  • Real. Es un numero real (con decimales) con signo. Puede almacenar números con valores entre 2.9e-39 y 1.7e38 (en notación científica, e5 equivale a multiplicar por 10 elevado a 5, es decir, podremos guardar números tan grandes como un 17 seguido de 37 ceros, o tan pequeños como 0,00...029 con 38 ceros detrás de la coma). Tendremos 11 o 12 dígitos significativos y ocupan 6 bytes en memoria.
Ejercicio propuesto: Crea un programa que te pida dos números reales y muestre en pantalla el resultado de multiplicarlos.
  • Boolean. Es una variable lógica, que puede valer TRUE (verdadero) o FALSE (falso), y se usa para comprobar condiciones.
Ejercicio propuesto: Crea un programa que cree una variable de tipo boolean, le asigne el valor TRUE y luego muestre dicho valor en pantalla.
  • Array (nota: algunos autores traducen esta palabra como "arreglo"). Se utilizan para guardar una serie de elementos, todos los cuales son del mismo tipo. Se deberá indicar el índice inferior y superior (desde dónde y hasta dónde queremos contar), separados por dos puntos (..), así como el tipo de datos de esos elementos individuales. Por ejemplo, para guardar hasta 200 números enteros, usaríamos:
lista: array[1..200] of integer
Se suele emplear para definir vectores o matrices. Así, una matriz de dimensiones 3x2 que debiera contener números reales sería:
matriz1: array[1..3,1..2] of real
Para mostrar en pantalla el segundo elemento de la primera lista de números (o de un vector) se usaría

write( lista[2] );

y para ver el elemento (3,1) de la matriz,

writeln( matriz1[3,1] );

  • Veremos ejemplos más desarrollados de cómo se usan los Arrays cuando lleguemos al tema 6, en el que trataremos órdenes como "for", que nos permitirán recorrer todos sus elementos.

  • Ejercicio propuesto: Crea un programa que reserve espacio para un Array de 3 números enteros, que asigne a sus elementos los valores 3, 5 y 8, y que después muestre en pantalla la suma de los valores de sus 3 elementos.

    • Record. La principal limitación de un array es que todos los datos que contiene deben ser del mismo tipo. Pero a veces nos interesa agrupar datos de distinta naturaleza, como pueden ser el nombre y la edad de una persona, que serían del tipo string y byte, respectivamente. Entonces empleamos los records o registros, que se definen indicando el nombre y el tipo de cada campo (cada dato que guardamos en el registro), y se accede a estos campos indicando el nombre de la variable y el del campo separados por un punto:


    program Record1;

    var
    dato: record
    nombre:
    string[20];
    edad:
    byte;
    end;


    begin
    dato.nombre:=
    'José Ignacio';
    dato.edad:=
    23;
    write(
    'El nombre es ', dato.nombre );
    write(
    ' y la edad ', dato.edad, ' años.');
    end.


      La única novedad en la definición de la variable es la aparición de una palabra end después de los nombres de los campos, lo que indica que hemos terminado de enumerar éstos.

    • Ya dentro del cuerpo del programa, vemos la forma de acceder a estos campos, tanto para darles un valor como para imprimirlo, indicando el nombre de la variable a la que pertenecen, seguido por un punto. El conjunto := es, como ya hemos dicho, la sentencia de asignación en Pascal, y quiere decir que la variable que aparece a su izquierda va a tomar el valor que está escrito a la derecha (por ejemplo, x := 2 daría el valor 2 a la variable x).

    •  

      Ejercicio propuesto: Crea un programa que defina una variable que sea un registro con dos campos: X e Y, ambos números enteros. El campo X debe valer 20, e Y debe valer 30. Después deberá mostrar en pantalla la suma de X e Y..



    Tema 2.3: With.

      Puede parecer engorroso el hecho de escribir "dato." antes de cada campo. También hay una forma de solucionarlo: cuando vamos a realizar varias operaciones sobre los campos de un mismo registro (record), empleamos la orden with, con la que el programa anterior quedaría


    program Record2;

    var
    dato: record
    nombre:
    string[20];
    edad:
    byte;
    end;


    begin
    with
    dato do
    begin
    nombre:=
    'José Ignacio';
    edad:=
    23;
    write(
    'El nombre es ', nombre );
    write(
    ' y la edad ', edad, ' años.');
    end;
    end
    .


      En este caso tenemos un nuevo bloque en el cuerpo del programa, delimitado por el "begin" y el "end" situados más a la derecha, y equivale a decir "en toda esta parte del programa me estoy refiriendo a la variable dato". Así, podemos nombrar los campos que queremos modificar o escribir, sin necesidad de repetir a qué variable pertenecen.

      Nota: aquí vuelve a aparecer la escritura indentada: para conseguir una mayor legibilidad, escribimos un poco más a la derecha todo lo que depende de la orden "with". No es algo obligatorio, pero sí recomendable.

      Y aun hay más sobre registros. Existe una posibilidad extra, conocida como "registros variantes", que veremos más adelante.

      Estos tipos básicos de datos se pueden "relacionar" entre sí. Por ejemplo, podemos usar un registro (record) para guardar los datos de cada uno de nuestros amigos, y guardarlos todos juntos en un array de registros. Todo esto ya lo iremos viendo.

      Por cierto, si alguien ve un cierto parecido entre un string y un array, tiene razón: un string no es más que un "array de chars". De hecho, la definición original de "string[x]" en Pascal estándar era algo así como "packed array [1..x] of char", donde la palabra packed indicaba al compilador que tratase de compactar los datos para que ocupasen menos.

    Actualizado el: 05-03-2006 20:16

    AnteriorPosterior