| principal | contenidos | <-- | --> | test | editor | indice |
|
Declaración de tipos |
|
Declaración de variables |
|
Declaración de subprogramas |
|
Cuerpo del programa
|
Antes de entrar en materia y explicar cada parte por separado, puedes ver el siguiente ejemplo que te permite observar algunas cosas del código en Pascal. Aunque en estos momentos no estas en disposición de entenderlo, puedes volver aquí más tarde para comprobar tus avances.
En este sencillo ejemplo (lo es, aunque ahora no te lo creas) se presentan seis secciones claramente diferenciadas. Como puedes ver, cada sección está caracterizada por alguna palabra especial. Como por ejemplo, var para la sección de variables. Estas palabras forman parte de un conjunto llamado palabras reservadas.
Muchas secciones no son obligatorias. Por tanto, en un programa no tienen por que aparecer todas estas palabras. Por otro lado, como ciertos compiladores exigen que el orden de las secciones sea el que aparece aquí, y otros no ponen ninguna restricción, lo mejor que puedes hacer es seguir siempre este orden.
A continuación tienes una tabla que empareja secciones con palabras reservadas. Además aparecen
en el orden correcto:
| Partes de un programa | Palabras reservadas |
| Cabecera (título) | program |
| Declaración de unidades | uses |
| Declaración de constantes | const |
| Declaración de tipos | type |
| Declaración de variables | var |
| Declaración de subprogramas | function o procedure |
| Cuerpo del programa | begin, end y punto(.) |
La cabecera es una sección
obligatoria, debe figurar en todos los programas. Debe comenzar con la palabra
reservada program seguida del nombre del programa y un ";". Con
esto ya se cumplirían los requisitos mínimos que debe tener una
cabecera, pero se puede y es muy recomendable incluír también
un comentario. Este comentario lo utilizamos para documentar el programa, que
es algo que la gente suele dejar en segundo plano, pero es de lo más
importante en programación. En el comentario se debe incluír el
mayor número de componentes de los que se citan a continuación:
Como en la mayoría de los casos, lo mejor para aprender algo es ver un ejemplo:
program MiPrimerPrograma;
(*************************************************)
(* Autor: Benito Santos Feijoo *)
(* Version: 1.0 *)
(* Fecha inicio: 25/11/2000 *)
(* Fecha modif.: 29/11/2000 *)
(* Objetivo: El que sea... *)
(* Fichero: nombre-fichero.pas *)
(*************************************************)
|
Nos encontramos en la parte correspondiente a la declaración del uso de unidades. En este
tutorial no se le dará importancia a esta sección, fundamentalmente por
dos motivos:
Sin profundizar demasiado en el tema, comentar que la palabra reservada que comienza la declaración
de unidades es uses y que va seguida de los nombres de las unidades que se quieran utilizar en el
programa separados por ",". Se finaliza la sección con un punto y coma ";". Evidentemente,
esta sección no es obligatoria.
uses nombre_unidad1,nombre_unidad2,...,nombre_unidad_n;
Esta sección no es obligatoria, y sólo tendrás que declararla si quieres definir alguna constante en tu programa.
A continuación se muestra la manera en que se escribe la sección de constantes.
Es tan fácil como empezar con la palabra reservada const, seguida de una lista de
parejas nombre_de_la_constante=valor_de_la_constante:
const identificador1=valor1;...;identificadorn=valorn;
Una constante es un objeto al que se le asigna un valor al declararlo y lo mantiene durante toda la
ejecución del programa. Si quieres profundizar en este tema puedes ir al capítulo sobre
constantes y variables. Mira el siguiente ejemplo y verás que declarar
constantes es una de las cosas más fáciles que hay en Pascal.
|
const
Min = 0;
Max = 1000;
Incremento = 5;
N = Max div Incremento; (* N vale 20 *)
Saludo = 'Hola'; (* Esta es una cadena de caracteres *)
Suma = (3 * 2) + (5 * 4); (* Suma tiene el valor 26 *)
|
En este ejemplo se declaran seis constantes. Las tres primeras son de tipo entero y se les asignan valores numéricos directamente. En la cuarta y la sexta se observa otra manera de darle valores enteros a constantes, y es mediante el uso de expresiones aritméticas. Y en la quinta, se declara una constante de tipo cadena de caracteres. Pero en este ejemplo no están reflejadas todas las posibilidades. Falta, por ejemplo, el declarar una constante de tipo real.
Esta sección no es obligatoria, y sólo tendrás que declararla si quieres
definir tus propios tipos de datos en el programa. Para programas sencillos no te hará
falta declarar tipos, te bastará con los que te proporciona Pascal (Integer, Real,
Boolean, String, ...). Aunque a veces es interesante declarar tipos para hacer el
código más legible. Por ejemplo:
|
(*tipo que define una cadena de 15 caract.*) type tNombre = String[15]; (*variable con espacio para 15 caract.*) var Nombre : tNombre; |
Declarar tipos de datos no es nada complicado. A continuación, tienes la forma genérica
que describe cómo hacerlo. La sección comienza con la palabra reservada type,
seguida de una lista de pares nombre_del_tipo=valor_del_tipo:
type identificador1=valor1;...;identificadorn=valorn;
Todo objeto de información que se use en Pascal tiene un tipo asociado. Pero en esta
sección no entraremos en detalle sobre esto. Dispones de un tema completo dedicado a
los tipos de datos. Para que vayas familiarizándote, en el
siguiente ejemplo se declararan unos cuantos:
|
type
tContador = Integer;
tPalabra = String[20];
tFinSemana = (Sabado,Domingo); (* tipo enumerado *)
tHorasDia = 0..23; (* tipo subrango *)
|
En este ejemplo se declaran cinco tipos de datos. En los dos primeros lo que se hace es dar otro nombre a tipos que ya existen en Pascal (integer,String). Como ya se ha mencionado, esto sirve para que el código del programa sea más legible; ya que no es lo mismo ver String[20], que ver tPalabra. Por otro lado, los dos últimos son dos ejemplos de tipos definidos por el usuario. Para este propósito Pascal dispone de dos tipos especiales, los enumerados y los subrangos.
Esta sección, aunque no es obligatoria casi siempre se declara. Pues un programa por muy
pequeño que sea, casi siempre va a hacer uso de variables. Por ejemplo, si utilizas
algún bucle en tu programa, tienes que tener por lo menos una variable para la
progresión de éste.
Nota: Cuando hablamos de un bucle nos estamos refiriendo a las estructuras de control
repetitivas. En ellas puedes profundizar en Control del flujo.
La forma de declarar variables es muy sencilla. Esta sección debe comenzar con la palabra
reservada var, seguida de una lista de parejas lista_de_variables=tipo_al_que_pertenecen.
Cada par debe ir seguido por un punto y coma. La lista_de_variables es uno o más nombres
de variables separados por comas:
var listaVar1:tipo1;...;listaVarn:tipon;
Una variable no representa más que una porción de memoria en donde guardamos un dato que dependerá del tipo al que pertenezca la variable. A diferencia de una constante, el valor de una variable puede cambiar durante la ejecución de un programa. Otra diferencia, es que a una variable no basta con declararla, sino que también es necesario iniciarla. Esto se refiere a darle un valor inicial, y es importante ya que si no lo hacemos, igual nos encontramos con errores cuando ejecutemos el programa. Todo esto se analiza en el capítulo dedicado a las variables.
Observa el siquiente ejemplo de declaración de variables:
|
var
I, J, K : Integer; (* valores enteros *)
Contador : Integer;
Radio : Real; (* valor real *)
Letra : Char; (* un caracter *)
|
En este ejemplo se declaran seis variables. Las cuatro primeras son de tipo entero. La quinta es de tipo real, o sea, un número con parte decimal. Y la sexta es un carácter, que no es lo mismo que una cadena de un carácter (String[1]). La diferencia puedes verla en el tema sobre tipos de datos.
Esta sección es muy importante, aunque para tus primeros programas no la necesitarás. En ella puedes declarar procedimientos y funciones (subprogramas) para que los uses en otros subprogramas o en el cuerpo principal. Todo lo relativo a esto lo encontrarás en el tema dedicado a la programación modular.
Puedes incluír cuantos procedimientos y funciones desees, incluso alternar entre ellos. Aunque debes de tener cuidado con el orden en el que los escribes. Ya que si un subprograma llama a otro, debería estar declarado primero el que es llamado.
La diferencia principal entre una función y un procedimiento
es que la primera devuelve un valor y el segundo no devuelve nada. A continuación, tienes
un ejemplo en el que se declaran una función y un procedimiento:
|
... function Suma(a:integer;b:integer):integer; begin Suma := a + b end; procedure Escribe(frase:string); begin writeln(frase) end; ... |
Son dos subprogramas muy sencillos. La función recibe como parámetros dos variables de tipo entero, las suma y devuelve su valor. El procedimiento recibe una cadena de caracteres e invoca a writeln para escribirla en pantalla.
También se le llama bloque del programa, y es junto con la cabecera, la única sección
obligatoria en un programa Pascal. Debe comenzar y finalizar con las
palabras reservadas begin y end respectivamente.
Muy imortante: Después de la palabra end, siempre tiene que ir un
punto que indica el final del programa.
Entre begin y end se escriben una o más sentencias, ya sean simples
o compuestas. Las sentencias pueden ser varias: asignaciones, llamadas a procedimientos y
funciones, sentencias selectivas (sentencias if), sentencias iterativas (sentencias
for, while). Veamos un pequeño ejemplo:
|
begin
i := 0;
while i<10 do
begin
writeln('El valor de i es ',i);
i := i + 1
end
end.
|
El ejemplo es muy sencillo. Se trata de un bucle que escribe en pantalla lineas que consisten en la frase "El valor de i es" seguidas del valor que tiene en ese momento la variable i (0..9).
|
|
Inicio
|
Contenidos
|
Introducción
|
Estructura
|
Variables
|
| Tipos de datos | E/S de datos | Sentencias | Control del flujo | Progr. modular | |