Estructuras Repetitivas

En muchas ocasiones podemos ver situaciones de la vida real, en donde, las mismas acciones se repiten un numero de veces; vemos por ejemplo, la acción que se produce en un equipo de sonido cuando colocas un casete de música y observas detenidamente el movimiento giratorio de los engranajes, estos se repiten y se repiten hasta que la cinta se ha rebobinado completamente o hasta que alguien la detiene, lo mismo también ocurre con los videojuegos que practicas; podemos citar al juego Mario Bros, aquí juegas hasta que se te acaben las vidas o rescates a la princesa.

Así mismo, ocurre en la mayoría de los programas, en la cual se requiere que un mismo conjunto de instrucciones se repitan un cierto número de veces tanto como sea necesario, hasta llegar a la solución final.

Como ejemplo de ello observemos el programa citado abajo, en donde se repiten varias veces las mismas instrucciones; pues en el que se deben almacenar cinco números en un arreglo númerico de tipo entero y después sumarlos.

PROGRAM Sumas; 
  
USES 
   Crt;
 
CONST 
   N = 5;

TYPE 
   VECTOR = ARRAY[1..N] OF INTEGER;

VAR 
   VectNumero: VECTOR;
   Suma: INTEGER;
   Promedio: REAL;

BEGIN 
   CLRSCR;
   WRITELN(Programa sin Instrucciones Repetitivas: ');
   WRITE('Digite Número: ');
   READLN(VectNumero[1]);
   WRITE('Digite Número: ');
   READLN(VectNumero[2]);
   WRITE('Digite Número: ');
   READLN(VectNumero[3]);
   WRITE('Digite Número: ');
   READLN(VectNumero[4]);
   WRITE('Digite Número: ');
   READLN(VectNumero[5]);
   Suma:= VectNumero[1]+ VectNumero[2]+ VectNumero[3]+ VectNumero[4]+ VectNumero[5];
   Promedio := Suma / N;
   WRITELN('La suma es = ',Suma:0:2);
   WRITELN('El promedio es: ',Promedio:0:2);
   READKEY;
END.

La escritura de este programa resulta demasiado tediosa, ya que se debe escribir cinco veces el mismo mensaje, la misma sentencia de lectura y ademas deben ser cinco, ni mas ni menos. Para solucionar este tipo de problemas disponemos de los ciclos o instrucciones repetitivas en Turbo Pascal, los cuales veremos en este tema.

En cada una de las instrucciones repetitivas que veremos a continuación, daremos una solución más práctica al ejemplo anterior, cabe destacar que todas estas funcionan hasta que se cumple con una condición que es la encargada de hacer detener el ciclo repetitivo y continuar con el resto de instrucciones del programa. 

Instrucción FOR... TO/DOWN

Esta instrucción ejecuta un ciclo o bucle repetitivo de instrucciones, a medida que va incrementando o decrementando automaticamente una variable de control hasta llegar ésta a un valor determinado. La variable de control presenta durante el ciclo de ejecución un valor inicial y un valor final, los cuales deben ser ambos del mismo tipo ordinal. La instrucción FOR presenta dos formas de ejecutarse, una es la forma incremental y la otra la forma decremental, tal como se describe a continuacíon.

Forma Incremental: en la forma incremental se usa la palabra TO, si la variable de control tiene un valor menor o igual que el valor final, en ese caso se ejecuta el bucle y se incrementa la variable de control. Cuando el valor de la variable de control es mayor que el valor final, se da por terminada la ejecución del bucle. La sintaxis para esta forma es:

FOR [VariableControl := ValorInicial] TO [ValorFinal] DO
 BEGIN
 Instrucción 1
 Instrucción 2
 .
 .
 .
 Instrucción N
 END;

Forma Decremental: la forma decremental es semejante a la forma incremental, solo que se usa la palabra DOWN, y la variable de control va evolucionando en sentido decreciente. La sintaxis para esta forma es:

FOR [VariableControl := ValorInicial] DOWNTO [ValorFinal] DO
 BEGIN
 Instrucción 1
 Instrucción 2
 .
 .
 .
 Instrucción N
 END;

La variable control del ciclo es generalmente de tipo INTEGER, pero tambien se puede en algunas ocasiones declarar de tipo carácter, y de ser así, la variable de control recorrá el alfabeto de la (‘a’) a la (‘z’) de letra en letra. La sintaxis sería entonces de la siguiente forma:

FOR [VariableTipoChar] := 'a'] TO/DOWNTO 'z' DO
 BEGIN
 Instrucción 1
 Instrucción 2
 .
 .
 .
 Instrucción N
 END;

Dos cosas muy importantes que se debe tener en cuenta son; primero, que las sentencias dentro del bucle no deben modificar el valor de la variable de control; segundo, que la comprobación de final de bucle se realiza antes de ejecutarse la sentencia FOR, por tanto, es posible que el bucle no se ejecute ninguna vez sí no se establece correctamente los valores iniciales y finales de la variable de control.

Tambián, que al igual que otras instrucciones de control, si el ciclo FOR tiene una sola instrucción no requiere usar las palabras delimitadoras BEGIN y END, en caso contrario sí las usará.

El programa mostrado a continuación usa la instrucción FOR para realizar la misma operación que el programa descrito al principio de esta pagina. Note la sencillez se su escritura en comparación con el programa diseñado sin ciclos repetitivos, aunque su escritura son diferentes, el resultado será el mismo:

PROGRAM Ejemplo_Istruccion_For_1;

USES 
   Crt;

CONST
   N = 5;

TYPE
   VECTOR = ARRAY[1..N] OF INTEGER;

VAR
   VectNumero: VECTOR;
   suma: INTEGER;
   promedio: REAL;
   i: BYTE;

BEGIN
   CLRSCR;
   WRITELN('Programa con la instrucción FOR TO');
   FOR i := 1 TO N DO
       BEGIN
       WRITE('Digite Número: ');
       READLN(VectNumero[i]);
       suma := suma + VectNumero[i];
       END;
   promedio := suma / N;
   WRITELN('La suma es = ', Suma);
   WRITELN('El promedio es: ', Promedio:0:2);
   READKEY;
END.

Para tener aún mayor claridad, a continuación se presentan otros programas de ejemplo, note también como en ellos no se usará ninguna unidad, en este caso emplerán la unidad estándar por defecto. Copie estos programas y ejecutelos en Turbo Pascal para que observe su funcionamiento:

PROGRAM Ejemplo_Istruccion_For_2;
{+----------------------------------------+
 | Este programa usa la sentencia FOR de  | 
 | forma incremental para escribir linea  |
 | a linea desde el número 1 hasta el 150 |
 +----------------------------------------+}
VAR
   Numero: INTEGER;

BEGIN
   FOR numero := 1 TO 150 DO 
      BEGIN
      WRITELN(numero);
      END;
   READLN;
END.
PROGRAM Ejemplo_Istruccion_For_3;
 {+----------------------------------------+
 | Este programa usa la sentencia FOR de  | 
 | forma decremental para escribir linea  |
 | a linea desde el número 150 hasta el 1 |
 +----------------------------------------+} 
VAR 
   Numero: INTEGER;

BEGIN
   FOR numero := 150 DOWNTO 1 DO
      BEGIN
      WRITELN(numero);
      END;
   READLN;
END.

Una de las desventajas del ciclo FOR TO/DOWN es que hasta que no se hallan ejecutado el número determinado de repeticiones no se detiene el ciclo, si alguna vez tiene algun problema de este tipo deberá recurrir al uso de las sentencias REPEAT o WHILE, como las que veremos a continuación.

Instrucción WHILE... DO

La instrucción WHILE... DO (que en español traduce: Mientras que... Haga), permite ejecutar una serie de sentencias un número indeterminado de veces hasta que se cumpla con una condición establecida, aunque tambien se puede hacer que trabaje de manera similar al ciclo FOR.

La instrucción WHILE primero evalua una expresión que detiene el ciclo y despues ejecuta sus instruccciones.  Si este contiene más de una instrucción, se necesitarán delimitarse entre las palabras BEGIN y END, en caso contrario no es necesario. La sintaxis de esta instrucción es la siguiente:

WHILE (Expresión) DO
    BEGIN
    Instrucción 1
    Instrucción 2
    .
    .
    .
    Instrucción N
    END;

El siguiente ejemplo usa la instrucción WHILE para realizar las mismas opereciónes del programa descrito al principio de esta página; compare estos dos programas y note las diferencias:

PROGRAM Ciclo_While;

USES
   Crt;

CONST
   N = 5;

TYPE
   VECTOR = ARRAY[1..N] OF INTEGER;

VAR
   VectNumero: VECTOR;
   Suma: INTEGER;
   Promedio: REAL;
   i: BYTE;

BEGIN
   CLRSCR;
   WRITELN('Lectura con ciclo While ');
   i := 0; {Note que primero se debe inicializar la variable de control}
   WHILE (i <= N) DO
      BEGIN 
      i := i + 1;
      {La variable controladora del ciclo se incrementa en un valor 
      determinado, en este caso Hemos escogido 1, pero podría ser otro}
      WRITE('Digite Número:');
      READLN(VectNumero[i]);
      Suma := Suma + VectNumero[i];
   END;
   promedio := Suma / N;
   WRITELN('La suma ss = ',suma);
   WRITELN('El promedio es ',Promedio:0:2);
   READKEY;
END.

Veamos otro ejemplo con el uso de la intrucción WHILE, el cual incrementa la variable de control de dos en dos, para escribir números del 1 al 100, contando también de dos en dos.

PROGRAM ciclo while 2;

VAR
   Numero: INTEGER;

BEGIN
   Numero := 1;
   WHILE Numero <= 100 DO
   BEGIN
   WRITELN(Numero);
   Numero := Numero +2;
   END;
   READLN;
END.

Una de las ventajas del ciclo WHILE es que puede evaluar variables de muchos más tipos que el ciclo FOR (recuerde que en este solo se pueden usar variables de tipo caráter y de números enteros) entre ellas destacamos las variables de tipo STRING, BOOLEAN, INTEGER, REAL y ARRAY.

Instrucción REPEAT... UNTIL

Esta instrucción (que en español traduce: Repita... Hasta que) actua de manera similar al ciclo WHILE... DO, con la pequeña diferencia de que; en este se primero se ejecutan las instrucciones y despues se evalua la condición que detiene el ciclo.  Esta instrucción no necesita las palabras delimitadoras BEGIN y END, aunque no genera ningún problema si estas se colocan. La sintaxis de esta instrucción es como sigue:

REPEAT
    Instrucción 1
    Instrucción 2
    .
    .
    .
    Instrucción N
UNTIL (Expresión)

Por última vez, citamos a continuación el ejemplo descrito al principio de esta página, pero haciendo uso de la instrucción REAPEAT para llegar a la misma solución; ejecute estos dos programas y note los resultados:

PROGRAM ciclo_repeat_until;

USES
   crt;

CONST
   N = 5;

TYPE
   VECTOR = ARRAY[1..N] OF INTEGER;

VAR
   VectNumero: VECTOR;
   Suma: INTEGER;
   Promedio: REAL;
   i: BYTE;

BEGIN
   CLRSCR;
   WRITELN('Lectura con ciclo REPEAT ');
   i := 0;{Notese que primero se debe inicializar la variable}
   REAPEAT
      i := i + 1;
      {La variable controladora del ciclo se incrementa en un valor 
      determinado, en este caso hemos escogido 1, pero podría ser otro}
      Write('Digite número :');
      Readln(Vector_numeros[i]);
      Suma:= Suma + Vector_numeros[i];
      UNTIL (i > = N);
   Promedio := Suma / N;
   Writeln('La suma es = ',Suma);
   Writeln('El promedio es = ',Promedio:0:2);
   READKEY;
END.

Aquí se presenta otro ejemplo con la instrucción REPEAT, el cual incrementa la variable de control de cinco en cinco, para escribir números del 1 al 200 con intervalos de cinco en cinco.

PROGRAM Ciclo_Repeat_Until2;

VAR
   Numero: INTEGER;

BEGIN
   Numero := 1;
   REPEAT
      WRITELN (Numero);
      Numero := Numero + 5;
      UNTIL Numero = 200;
   READLN;
END.

Estructuras Condicionales

En nuestra vida diaria, a veces nos topamos en un momento en el que debemos tomar una determinada decisión, en la cual tenemos que llevar a cabo una de entre varias acciones según las situación que más nos convenga. De manera similar en que nosotros logramos tomar decisiones, también podemos hacer que un programa o aplicación tome la decisión de ejecutar uno de varios procedimientos según las condiciones establecidas; y esto es posible gracias las estructuras condicionales que veremos a continuación.

Estructura condicional IF… THEN

Esta estructura se compone por una agrupación lógica de instrucciones bifurcadas mediante dos cláusulas que permiten ejecutar solamente uno de entre dos bloques de instrucciones dependiendo del valor de una expresión. Su sintaxis es la siguiente:

IF [Expresión] THEN

   BEGIN
      Instrucción 1;
      Instrucción 2;
      ...
      Instrucción 5;
   END
    
ELSE

   BEGIN
      Instrucción 6;
      Instrucción 7;
      ...
      Instrucción n;
   END;

Donde: Expresión es la proposición lógica que representa una condición que se desea evaluar. Si el valor de la expresión es True (Verdadero, en español), solamente se ejecutaran las instrucciones dentro de la cláusula IF… THEN. En caso contrario, si el valor de la expresión es False (Falso, en español), solo se ejecutarán las instrucciones dentro de la cláusula ELSE.

Note en la sintaxis que las instrucciones precedidas a la cláusula IF… THEN y la cláusula ELSE, deben ir delimitadas dentro de las palabras reservadas BEGIN y END. Note además, que después de una palabra reservada dentro de ésta estructura no debe ir un punto y coma; si éste se escribe, se acortará allí la estructura condicional y se producirá un error de compilación. Solo se puede escribir el punto y coma al final de dicha estructura, es decir en la última de las palabras END.

Para entender mejor realicemos el siguiente ejemplo de un programa en donde se evalúa la edad a una persona, y se verifica si es mayor de edad o no:

PROGRAM Evaluar_Edad;

USES Crt;

VAR edad: BYTE;

BEGIN        {Inicio del programa}
  ClrScr;
  Write('Digite su edad: ');  {Solicita al usuario ingresar su edad}
  Read(edad);  {Almacena el dato ingresado en la variable Edad}

  IF edad < 18 THEN    {Evalua si la edad < 18}

    BEGIN    {Ejecuta la cláusula If sí la expresión es VERDADERA}
       WriteLn('Eres un Menor de Edad);
    END      {Fin de la cláusula If}

  ELSE

    BEGIN    {Ejecuta la clausula Else sí la expresión es FALSA}
       Write('Eres un Adulto');
    END;     {Fin de la cláusula Else}

  WriteLn('Presione cualquier tecla para salir');
  ReadKey;   {Espera a que se presione cualquier tecla}
END.         {Fin del programa principal}

En esta estructura condicional, también es posible omitir la cláusula ESLE si solo se desea que un programa decida entre ejecutar o no un único bloque de instrucciones; en este caso solo existiría la parte de la cláusula IF… THEN. Así el mismo programa anterior se podría escribir de la siguiente manera:

PROGRAM Evaluar_Edad;

USES Crt;
   
VAR edad: BYTE;

BEGIN
   ClrScr;
   
   IF edad < 18 THEN
      BEGIN
         WriteLn('Eres Menor de Edad');
      END;

   WriteLn('Presione cualquier tecla para salir');
   ReadKey;
END.

Cuando las cláusulas IF… THEN o ELSE contienen simplemente una única instrucción, las palabras delimitadoras BEGIN y END pueden ser omitidas. De esta manera, podríamos escribir el código de forma más simple; tal como sigue a continuación:

IF edad >= 18 THEN Write ('Eres mayor de edad')
ELSE Write ('Eres menor de edad');

Veamos otro ejemplo de un pequeño programa que simula una calculadora sencilla; en el cual se usan varias cláusulas IF… THEN de una sola instrucción anidadas dentro de otras:

PROGRAM Calculadora1;
{
+-------------------------------------------+
| Cada sentencia IF THEN evalua el operador |
| elegido y dependiendo de éste se realiza  |
| la operación respectiva.                  |
+-------------------------------------------+
}
USES
  crt; {Utiliza la unidad CRT para ejecutar rutinas de pantalla}

VAR
  num1, num2: INTEGER;
  resultado: REAL;
  Operador: CHAR;

BEGIN
  ClrScr;     {Borra la pantalla y coloca el cursor al principio}
  num1 := 0;  {Inicialización de variables}
  num2 := 0; 
  WriteLn ('Calculadora Sencilla');
  Write ('Digite el primer número:');
  Read(Num1);
  Write ('Digite el segundo número:');
  ReadLn(Num2);
  WriteLn ('Digite el operador +, -, *, /');
  Operador := ReadKey;

  IF operador = '+' THEN resultado := num1 + num2 {Operación de Suma}
  ELSE
     IF operador = '-' THEN resultado := num1 - num2 {Operación de Resta}
  ELSE
     IF operador = '*' THEN resultado := num1 * num2 {Op. de Multiplicar}
  ELSE
     IF operador = '/' THEN resultado := num1 / num2 {Operación de Dividir}
  ELSE
     WriteLn ('¡Operador invalido!');

  WriteLn ('El resultdo es: ', resultado:0:3);
  ReadKey;
END.

Estructura condicional CASE… OF

En algunas ocasiones, es necesario que un programa requiera decidir entre ejecutar una de múltiples acciones en función del valor una única expresión; en este caso, resulta poco conveniente utilizar varias sentencias IF… THEN anidadas, ya que a pesar de su eficacia esto puede ser propenso a errores de lógica con los que obtendríamos resultados inesperados. Como una mejor alternativa disponemos de la estructura condicional CASE… OF, la cual resulta más sencilla y eficaz. Su sintaxis es la siguiente:

CASE [Expresión] OF

  Valor1: BEGIN    {Cláusula asociada al Valor1}
             Instrucciones
          END;

  Valor2: BEGIN    {Cláusula asociada al Valor2}
             Instrucciones
          END;

  ValorN: BEGIN    {Cláusula asociada al ValorN}
             Instrucciones
          END
  ELSE             {Cláusula Else}
          BEGIN
             Instrucciones
          END
END;

Donde: Expresión es una proposición numérica o alfanumérica que puede tomar distintos valores, y Valor1, Valor2, y ValorN, son los distintos valores que se comparan con la expresión, y cada valor está asociado con una cláusula condicional de la estructura.

Si la expresión evaluada toma alguno de los valores asociados a las cláusulas, solamente se ejecutará el bloque de instrucciones correspondiente a la cláusula vinculada con dicho valor. Cuando la expresión tome un valor distinto a los valores de las cláusulas asociadas, se ejecutarán las instrucciones de la cláusula ELSE.

Para pasar a la práctica, realizaremos una versión de la calculadora anterior, que usaba las sentencias IF… THEN, pero usando esta vez la sentencias CASE… OF; notará como el código resulta más sencillo y fácil de entender que en la calculadora anterior:

PROGRAM Calculadora2;
{
+-------------------------------------------+
| La instrucción CASE OF evalua el operador |
| elegido y dependiendo de éste realiza la  |
| operación respectiva.  Note también que   |
| cada opción tiene solo una sentencia, por |
| tanto omiten las palabras BEGIN y END     |
+-------------------------------------------+
}
USES
  crt;

VAR
  numero1, numero2, resultado: REAL;
  operador: CHAR;

BEGIN

  ClrScr;        {Borra la pantalla y coloca el cursor al principio}
  numero1 := 0;  {Inicialización de variables}
  numero2 := 0;
  resultado := 0;
  WriteLn('Operaciones Básicas');   {Mostrar mensajes al usuario}
  Write('Digite un número: '); 
  ReadLn(numero1);                  {Lee el primer número}
  Write('Digite otro número: '); 
  ReadLn(numero2);                  {Lee el segundo número}
  WriteLn('Digite el signo de operacion [+, -, *, /]: ');
  operador := ReadKey;              {Lee el operador}

  CASE operador OF 
     '+': resultado := numero1 + numero2; {Operación de Suma}
     '-': resultado := numero1 - numero2; {Operación de Resta}
     '*': resultado := numero1 * numero2; {Operación de Multiplicación}
     '/': resultado :=numero1 / numero2;  {Operación de División}
  ELSE         {En caso de que se ingrese un operador diferente}
     Write('¡Operador invalido!');
  END;         {Fin de la estructura CASE}
        
  WriteLn('Resultado sin formato : ',resultado:0:2); {Muestra el resultado}
  ReadKey;     {Espera a que se presione cualquier tecla}
 
END.           {Fin del programa}

Instrucciones básicas de entrada y salida

La mayoría de tareas que realiza un computador requiere que el usuario ingrese los datos necesarios para poder llevar a cabo todas las operaciones y procedimientos, que posteriormente devolverán los resultados de la información final procesada. Hay varias formas de introducir datos en un computador, ya sea a través del teclado, el mouse, desde una unidad de CD-ROM u otro dispositivo de entrada; del mismo modo también hay varias formas de extraerle información, por medio del monitor, la impresora, un módem, u otro dispositivo de salida.

Monitor y teclado Impresora

En Turbo Pascal existen dos instrucciones sencillas que permiten realizar las tareas basicas de entrada y salida de datos, tales como las instrucciones Read, Write y Readkey, las cuales veremos a continuación.

Escribir datos en la pantalla

Una de las instrucciones más utilizadas en Turbo Pascal es la intrucción Write, la cual es un procedimiento que permite escribir en la pantalla cualquier tipo de datos, lo que resulta muy util para comunicar cualquier mensaje al usuario. La sintaxis para esta instrucción es la siguiente:

Write(Dato1, Dato2, ..., DatoN);

Donde: Dato1, Dato2, y DatoN, son parametros que representan un elemento que contenga la información que se desea visualizar en pantalla, los cuales pueden ser, una cadena de texto, un valor numérico, el valor de una variable o una constante, o incluso también puede ser el valor del resultado de una expresión como las que se explicaron anteriormente.

La instrucción Write posee una variante, la cual es la instrucción Writeln cuya función es la misma que la primera, solo que esta coloca el cursor al comienzo de la siguiente linea de la pantalla despues de escribir los datos. La sintaxis para esta instrucción es la misma que la anterior, así por ejemplo, podemos utilizar estas instrucciones como sigue:

Program Escribir_pantalla;
{
+-------------------------------------------+
|Recuerde: Para ejecutar un programa pulse  |
|las combinaciones de teclas CTRL+F9 y luego|
|ALT+F5 para ver los resultados en pantalla |
+-------------------------------------------+
}
Uses Crt;

Var MiEstatura: String[8];

Begin
MiEstatura := '1.68 mts';
Writeln('Bienvenidos a mi página');
Write('Yo tengo: ', 25, ' años, ');
Writeln('mi estatura es: ', MiEstatura);
Writeln('El resultado es igual a: ', 500 + 25);
End.

Leer datos desde el teclado

Una de las formas de introducir información a un programa, es mediante la instrucción Read, la cual permite leer un dato introducido por el usuario desde el teclado, para luego almacenarlo en una determinada variable. La sintaxis para esta sentencia es la siguiente:

Read (Variable);

En donde variable es un parametro que representa el nombre de una variable del mismo tipo de datos que el dato leido por la instrucción, ya sea de tipo string, integer, real o boolean.

Existe también una variante para esta sentencia, la instrucción Readln, que realiza lo mismo que la primera, pero con la diferecia de que coloca el cursor en la siguiente linea una vez se lea el dato. Usted puede usar cualquiera de las dos.

Cuando se ejecuta esta instrucción, el programa espera a que el usuario escriba un dato y luego se debe pulsar la tecla Enter para que el programa continúe. Un ejemplo de un programa sencillo que utilice las intrucciones anteriormente descritas, se ecribiría de la siguiente forma:

Program Leer_teclado;

Uses
Crt;

Var
MiMensaje: String[40];

Begin
Write('Escriba un mensaje y luego pulse la tecla ENTER: ');
Readln(MiMensaje);
Writeln('El mensaje que escribiste fue: ' , MiMensaje);
Write('Ahora pulse ENTER para salir');
Readln;
End.

Leer un único caracter desde el teclado

Otra manera de introducir información a un programa, es mediante la función Readkey, la cual permite leer un único caracter desde el teclado y almacenarlo en si misma. El caracter de la tecla pulsada no se muestra en pantalla, pero el valor de la función puede ser usado en una instrución o ser almacenarlo en otra variable del programa. Esta funcion resulta muy util para determinar que tecla se ha pulsado. Por ejemplo:

Program Leer_tecla;

Uses
Crt;

Var
MiTecla: Char;

Begin
Writeln('Por favor, pulse cualquier tecla');
MiTecla := Readkey;
Writeln('La tecla que pulso fue: ', MiTecla);
Write('Ahora pulse cualquier tecla para salir');
Readkey;
End.

Borrar el contenido de la Pantalla

A medida que los programas se van ejecutando la pantalla se va llenando de datos, en algún momento dado necesitaremos despejar la pantalla para escribir nueva información, esta tarea es posible por medio de la instrucción Clrscr, la cual es un procedimiento borra completamente el contenido de la pantalla o la ventana actual. Esta instrucción no necesita ningún parametro y su sintaxis es:

Clrscr;

El procedimiento Clrscr solo se encuentra displonible en la unidad Crt, por lo que debemos especificar dicha unidad en la sección de unidades para poder utilizarlo dentro de un programa.

Cada vez que se termina de ejecutar un programa, los resultados de sus operaciónes permanecen escritos en la pantalla si estos no se borran, por esta razón, es recomendable utilizar este procedimiento como primera instrucción para borrar de la pantalla los resultados de los programas ejecutados con anterioridad, despejando asi la pantalla para la nueva aplicación que se vaya a ejecutar. Veamos un ejemplo:

Program Borrar_con_Clrscr;

Uses Crt;

Begin
Clrscr;         {Borra los resultados de programas anteriores}
Writeln('Bienvenidos a mi página');
Write('Yo tengo ', 25, ' años, ');
Writeln('mi estatura es 1.68 mts');
Writeln('El resultado es igual a ', 500 + 25);
Write('Pulse Enter para borrar la pantalla');
Readkey;
Clrscr;         {Borra los nuevos resultados}
Write('Ahora pulse una tecla para salir');
Readkey;
End.

Formato de salida de números reales

El formato por defecto con el que se visualizan los números reales en la pantalla, es el de notación cientifica. A veces ésta notación resulta inadecuana para presentar un número. Con el fin de mejorar el aspecto de presentación en la pantalla, en las intrucciónes Write y Writeln se pueden especificar el formato de escritura de los números reales, indicando la cantidad de espacios de tabulación hacia la derecha en donde se alineará el número en pantalla, y la cantidad de cifras que mostrará en su parte decimal. La sintaxis para indicar el formato de salida para los números es la siguiente:

Write(Numero:m:n);
Writeln(Numero:m:n);

Donde m es la cantidad de espacios hacia la derecha en donde se alineará el número, y n indica el número de cifras que empleará la parte decimal; éste argumento sólo se emplea cuando el argumento Numero es de tipo real. Por ejemplo:

Writeln(3.14159265 :25:4);

El ejemplo de la sentencia anterior daría como resultado el número 3.1416, como notará el número se redondea al número de cifras decimales indicado; también se alineará con una tabulación de 25 espacios hacia la derecha de la pantalla. Realizando el programa de ejemplo que se presentará a continuación, entenderá mejor el uso de éstos parametros de formato.

Program Escribir_Numeros_Reales;

Uses
crt;

Var
num: real;

Const
Pi: Real = 3.14159265;

Begin
num := 1234567.89;
Clrscr;
Writeln(num);       {Escribe con el formato por defecto}
Writeln('Fíjate en donde se alinean los siguientes números');
Writeln(Pi:42:3);   {Alinea a 42 espacios a la derecha, 3 decimales}
Writeln(num:42:4);  {Alinea a 42 espacios, 4 decimales}
Writeln(num:23:2);  {Alinea a 42 espacios, 2 decimales}
Writeln(num:23:1);  {Alinea a 42 espacios, 1 decimal}
Writeln(num:23:0);  {Alinea a 42 espacios, 0 decimales}
Writeln(num:0:3);   {Cuál será la alineación?}
Writeln(num:42);    {Cuál será la alineación?}
Readkey;
End.

Estructura de un programa en Pascal

Al igual que una carta o un informe escolar escrito deben seguir siempre un modelo de escritura; así también, un programa en Lenguaje Pascal deberá seguir una estructura básica para la escritura de todas las instrucciones que lo conforman. En el mismo orden de la lista a continuación, se escriben cada una las secciones que conforman la estructura de un programa en Pascal, ya sea escrito tanto en el compilador Turbo Pascal 7.0 o en el compilador Free Pascal:

  1. Cabecera del programa
  2. Sección de Unidades o Librerias
  3. Sección de Declaraciones
    • Declaración de Etiquetas
    • Declaración de Constantes
    • Declaración de Tipos definidos por Usuario
    • Declaración de Variables
  4. Funciones y Procedimientos
  5. Cuerpo del programa Principal

Cabecera del programa

En la cabecera del programa se especifica el nombre y los parametros del programa, esta es solamente informativa y no tiene ningúna utilidad para programa en si. Esta sección corresponde a la primera linea del programa, la cual esta encabezada por la palabra reservada PROGRAM, seguida de un nombre cualquiera para el programa definido por el usuario. La sintaxis para esta sección es la siguiente:

PROGRAM NombrePrograma;

El primer carácter para el nombre debe ser obligatoriamente una letra, y los caracteres siguientes a la primera letra; pueden letras, números, o el carácter guión bajo [_], no se permiten usar espcios en blanco, ni tampoco se pueden usar las palabra reservadas como nombre de programa. Por ejemplo:

PROGRAM Mi_1_Programa;

Sección de Unidades o Librerias

En ésta sección sigue después de la cabecera, y en ella se deben indicar las unidades o librerias que serán utilizadas por el programa. Las unidades son módulos de instrucciones compiladas independientemente en un archivo, las cuales incorporan una serie de procedimientos y funciones creados para simplificar la programación de ciertas tareas dentro de un programa, estos módulos (librerías) se especifican utilizando la palabra USES, seguido de los nombres de la librerías que se van a utilizar.

Algunas de las librerías mas utilizadas son las unidades CRT, DOS, GRAPH, PRINTER. Por ejemplo, para epecificarle al programa que utilize las unidades CTR y GRAPH, en la sección de unidades se escribe de la siguiente forma:

USES Crt,Graph;

Sección de Declaraciones

En esta seccion es donde se especifican los elementos, tales como las etiquetas, constantes, variables, procedimientos, y funciónes que se necesitarán dentro del programa principal para que funcione correctamente. Se pueden declarar varios de estos elementos y en cualquier orden. La manera como se deben declarar tales elementos ya se explicó en capitulos anteriores, lo único que debenos conocer ahora es que estas declarciones se deben ubicar después de la sección de unidades. Observe en el siguente ejemplo en el que se declaran dos constantes y dos variables:

CONST
Pi = 3.1416;
MiMensaje = '¡VIVA COLOMBIA!'; 

VAR
NombreCliente: string[15];
EdadCliente: Integer;

Cuerpo del Programa Principal

El cuerpo del programa es el que contiene las instrucciones o sentencias que serán ejecutadas cuando el programa esté funcionando en el computador. Las intrucciones del programa principal se encuentran acotadas entre las palabras reservadas BEGIN y END. En el siguiente modelo de ejemplo se indica la forma como debe escribirse el cuerpo del programa:

BEGIN

Sentencia1; 
Sentencia2;
Sentencia3;
...
SentenciaN; 

END.

Ejemplo de un programa en Pascal

Ejemplo de un programa en Turbo Pascal

En la imagen anterior se puede apreciar la escritura de un programa muy sencillo, el cual contiene algunos de los elementos de las secciones ya mencionadas en este artículo. No se preocupe si aún no entiende alguna de las instrucciones del programa, ya éstas que se explicarán más adelante; pero, en caso de que usted tenga instalado en su computador el compilador Turbo Pascal o Free Pascal, puede copiar el siguiente codigo de este programa y ejecutarlo para así ver su funcionamiento.

PROGRAM Mi_Primer_Programa;

USES 
Crt;

VAR
MiMensaje: String[22];

BEGIN
clrscr;
MiMensaje := '¡Hola Colombia linda!';
TextColor(red);
Write(Mensaje);
Readln
END.

Reglas de escritura de un programa

Note en el programa de ejemplo anterior, como casi todas sus instrucciones llevan un punto y coma (;) al final; esto es debido a que es una regla básica en Lenguaje Pascal que todas las líneas de instrucciones deben separarse unas de otras mediante dicho signo, salvo algunas excepciones que expresarán a continuación. Las reglas que se deben tener en cuenta para la separación entre varias sentencias son las siguientes:

  1. Cada una de las sentencias se deben separar mediante un punto y coma (;).
  2. Se debe omitir el punto y coma si una sentencia termina en una palabra reservada.
  3. Se puede omitir el punto y coma si una instrucción va seguida de las palabras reservadas END o UNTIL.
  4. La palabra reservada END al final del programa debe terminar en punto final (.).

Palabras reservadas e identificadores

palabras reservadas en el Lenguaje Pascal

Las palabras reservadas están establecidas para tener un significado especial y un uso único dentro del lenguaje; estas palabras son por lo general del idioma inglés, algunas solo son abreviaturas de las mismas; por lo tanto, no pueden ser utilizadas para darle nombre a las variables, constantes, funciones y procedimientos que sean definidos por el usuario o programador. A continuación se muestra un listado de algunas de las palabras reservadas que disponen los compiladores Turbo Pascal y Free Pascal:

Absolute And Array
Asm Begin Case
Circle Const Constructor
Destructor Div Do
Downto Else End
External File For
Forward Function Goto
If Implementation In
Inline Interface Interrupt
Label Mod Nil
Not Object Of
Or Packed Private
Procedure Program Random
Record Rectangle Repeat
Set Shl Shr
String Then To
Type Unit Until
Uses Var Virtual
While With Xor

No es necesario aprendernos todas estas palabras en un solo día, ya que con el tiempo y la práctica habremos aprendido un gran número de éstas, sin siquiera darnos cuenta. Para conocer más palabras reservadas, puede encontrar más información sobre este tema consultando el índice de temas de ayuda de Turbo Pascal.

Identificadores

Todas las variables, constantes, tipos de datos, funciones y procedimientos que son definidos por el usuario deben tener un nombre especifico que permita reconocerlos dentro del programa. En los lenguajes de programación, a estos nombres se les conoce como Identificadores. Así pues, todos los nombres de las variables, constates u otros elementos que nosotros definamos en el programa, excepto las palabras reservadas, son denominados como identificadores. El lenguaje Pascal, al igual que otros lenguajes de programación, tiene sus propias reglas al elegir nombres para sus identificadores; las cuales son las siguientes:

  1. El nombre puede tener una longitud máxima hasta 127 caracteres
  2. El primer carácter debe empezar obligatoriamente por una letra o el carácter guión bajo (_).
  3. Los caracteres siguientes al primero pueden ser letras, dígitos o el carácter guión bajo (_).
  4. No se permiten espacios, ni caracteres especiales (%, $, &, @, !, á, ñ, Ñ, …).
  5. No se permite usar nombres repetidos, ni palabras reservadas.

Por ejemplo:

Nombres permitidos Nombres no permitidos
TotalFactura Total Factura
Total_Factura Total$
PrimaNavidena PrimaNavideña
LongitudMaxima LongitudMáxima
_Area1 2_Area

Los usuarios pueden elegir los nombres de sus variables y funciones con gran libertad siempre y cuando se respeten las reglas del lenguaje, y no utilice palabras reservadas en los nombres de los identificadores. Aunque no es obligatorio, se aconseja que los identificadores tengan cierta relación con el uso que se le va a dar; así por ejemplo, si un identificador hace referencia a un procedimiento, utilice nombres de verbos para relacionarlo con el proceso que realice, de modo que convendría usar un procedimiento llamado BorrarZona, si éste se utiliza para borrar un área especifica de la pantalla.