PASCAL

Estructura de PASCAL

1. Todo programa en pascal comienza con la palabra program y el nombre del programa (max. 8 caracteres, sin espacios en blanco) seguido de un punto y coma. Ejemplo:

program nomina;

2. Es conveniente utilizar la cláusula uses crt para utilizar las propiedades de la pantalla. Ejemplo:

uses crt;

3. A continuación definimos las constantes: son aquellas que tienen un valor que no cambiará en todo el programa. Se comienza con la palabra const. Ejemplo:

const
linea = 66;
max = 100;
min = 0;
n = 30;

4. A continuación definimos nuestros tipos de datos. Hay dos tipos de datos en pascal: los tipos de datos estándares, es decir que el compilador pascal los reconoce automáticamente, como son: integer, real, boolean, char, byte. Estos tipos de datos no son necesarios definirlos aqui, sino directamente se asignan a las variables. Los tipos de datos que hay que colocar aqui son aquellos definidos por el usuario. Ellos son: los tipo string (cadenas de caracteres), los arreglos (vectores y matrices), los registros, los archivos y los apuntadores. Se comienza con la palabra type. Ejemplo:

type
nom : string[40]; —> nom es un tipo de datos string de 40 caracteres.
alum : array[1..5] of integer; —> alum es un vector de cinco elementos tipo entero
nota1 : array[1..30,1..4] of real;—> nota1 es una matriz de 30 filas y cuatro columnas

emp : record —> emp es un registro formado por tres campos:
ci: string[9]; ci, nya y sueldob.
nya : string[40];
sueldob : real;
end;

emplea : file of emp; —> emplea es un archivo conformado por registros
tipo emp

5. Posteriormente definimos las variables, asociadas a los tipos de datos que hemos definido en type, o aquellas que son de tipo estandar: enteras (integer), reales (real), booleanas. etc.
Se comienza con la palabra var. Ejemplo:

var
i,j,k : integer;
promedio : real;
nombre : nom; —> Obsérvese la relación de la variable con el tipo de datos
alumno : alum; definido en el type
notas : nota1;
empleado : emplea;
regemp : emp;

Recuérdese que en el programa trabajaremos con las variables. Ejemplo:
read(nombre);

6. Si tenemos subprogramas, procedimientos o funciones se definen en este lugar. Comienzan con la palabra procedure y el nombre del procedimiento y termina con la palabra end y punto y coma. Ejemplo:

procedure listar;
const
……
type
……
var
……
begin
……
end;

Un procedimiento tiene la misma estructura del programa principal. Las variables que se utilizan en el procedimiento sólo sirven para ser utilizadas en el procedimiento (variables locales), mientras que las que hemos definido en el programa principal son globales, es decir pueden utilizarse en cualquier parte del programa.

7. Por último, escribimos el programa principal, el cual comienza con la palabra begin y termina con la palabra end seguida de un punto. Dentro del begin y el end final se encuentran todas las instrucciones y llamadas a los procedimientos que hemos definido anteriormente. Ejemplo:

begin
write(‘Escriba el nombre del estudiante: ‘);
readl(nombre);
……..
listar; —> aqui llamamos al procedimiento listar definido antes
……..
end.

Tipos de Datos

Los tipos de datos básicos en Pascal incluyen:

• integer (entero)
• real
• char (un byte, un carácter)
• boolean (lógico: verdadero -true- o falso -false-)

   El Pascal estándar no prevé nada para el tipo de datos de cadena de caracteres, pero los compiladores más modernos si lo hacen. Programadores Pascal avanzados utilizan punteros para la asignación dinámica de memoria, objetos para la programación orientada a objetos, y muchos otros, pero esto te ayudará a comenzar

   Más información sobre los tipos de datos de Pascal:

• El tipo integer puede contener valores enteros desde -32768 hasta 32767. Este es el rango de valores con signo que puede ser almacenado en una palabra de 16 bits, y es herencia de la época en que las CPUs de 16 bits eran comunes. Por compatibilidad con versiones anteriores, un entero de 32 bits con signo es un entero largo (longint) y puede almacenar una gama mucho mayor de los valores.
• El tipo real tiene un rango desde 3.4x10-38 hasta 3.4x1038, además del mismo rango para números negativos. Los valores reales se almacenan en la computadora de manera similar a la notación científica, con una mantisa y exponente, con algunas complicaciones. En Pascal, se pueden expresar los valores reales en el código en la notación de punto fijo o en notación científica, con el carácter Eseparando la mantisa del exponente. Por lo tanto 452.13 es lo mismo que 4.5213e2.
• El tipo char contiene caracteres. Asegúrate de incluirlos entre comillas simples, así: 'a' 'B' '+' El Pascal estándar utiliza caracteres de 8 bits, no de 16 bits, de modo que Unicode, que se utiliza para representar en todos los conjuntos de caracteres de los idiomas del mundo en un sistema de Código Unificado, no está soportado.
• El tipo WideChar es un carácter de dos octetos (un elemento de un DBCS: Double Byte Character Set -conjunto de caracteres de dos bytes-) y puede contener un carácter Unicode.
• Free Pascal soporta la implementación de Delphi del tipo PChar. PChar se define como un puntero a un tipo Char, pero permite operaciones adicionales. El tipo PChar puede ser mejor entendido como el equivalente Pascal de una cadena C terminada en nulo, es decir, una variable de tipo PChar es un puntero que apunta a una matriz de tipo Char, que se termina por un carácter nulo (#0). Free Pascal soporta la inicialización de constantes con tipo PChar, o una asignación directa. Por ejemplo, los trozos de código siguientes son equivalentes:

 program uno;  
 var P : PChar;  
 begin  
   P := ’Esta es una cadena terminada en nulo.’;  
   WriteLn (P);  
 end.

 program dos;  
 const P : PChar = ’Esta es una cadena terminada en nulo.’;  
 begin  
   WriteLn (P);  
 end.

• Free Pascal soporta el tipo String tal como se define en Turbo Pascal: una secuencia de caracteres con una especificación de tamaño opcional. También es compatible con ansistrings (con longitud ilimitada) como en Delphi. Y pueden ser declarados así:

 variable_nombre : string;                    // si no se especifica la longitud, el valor predeterminado será 255
 variable_nombre : string[longitud];          // donde:  1 < longitud <= 255

• El tipo predefinido ShortString está definido como una cadena de tamaño 255.
• AnsiStrings son cadenas que no tienen límite de longitud. Dsipone de un contador de referencias y está garantizado para terminar en un valor nulo. Internamente, un AnsiString se trata como un puntero: el contenido real de la cadena se almacena en el montón, y tanta memoria como sea necesaria para almacenar el contenido de la cadena se asignará.
• Widestrings (utilizada para representar cadenas de caracteres Unicode) se implementan en la misma forma que ansistrings: un contador de referencias, terminada en matrices nulas, sólo que se implementan como matrices de WideChars en lugar de Chars normales.
• El tipo boolean (lógico o booleano) sólo puede tener dos valores: true y false

   Un ejemplo de declaración de varias variables es:

 var
  edad, anyo, grado : integer;
  circunferencia : real;
  GradoObtenido : char;
  Aprobado: Boolean;

   Del manual de FPC

Tipos enteros

Tipo	Rango	Bytes
Byte	0 .. 255	1
Shortint	-128 .. 127	1
Smallint	-32768 .. 32767	2
Word	0 .. 65535	2
Integer	smallint o longint	2 o 4
Cardinal	longword	4
Longint	-2147483648 .. 2147483647	4
Longword	0..4294967295	4
Int64	-9223372036854775808 .. 9223372036854775807	8
QWord	0 .. 18446744073709551615	8

   Free Pascal realiza una conversión automática de tipos si en las expresiones se utilizan diferentes tipos de enteros .

Tipos real

Tipo	Rango	dígitos significativos	Bytes
Real	depende de la plataforma	???	4 or 8
Single	1.5E-45 .. 3.4E38	7-8	4
Double	5.0E-324 .. 1.7E308	15-16	8
Extended	1.9E-4932 .. 1.1E4932	19-20	10
Comp	-2E64+1 .. 2E63-1	19-20	8
Currency	-922337203685477.5808	922337203685477.5807	8

Tipos lógicos (boolean)

Tipo	Bytes	Ord(True)
Boolean	1	1
ByteBool	1	Valor distinto de cero
WordBool	2	Valor distinto de cero
LongBool	4	Valor distinto de cero

Estructura Repetitiva

Mientras... (while)

Hemos como visto podemos crear estructuras repetitivas con la orden "for". Pero muchas veces no sabremos la cantidad de veces que se debe repetir un bloque de un programa, sino que deberemos repetir mientras se cumpla una condición. La primera forma de conseguirlo es con "while", que se usa:

while condicion do
    Sentencia;

Que se podría traducir como "MIENTRAS se cumpla la condición HAZ sentencia".

Un ejemplo que nos diga el doble de todos los números que queramos podría ser:

(* WHILE1.PAS, "while" para ver el doble de varios numeros *)
(* Parte de CUPAS5, por Nacho Cabanes                      *)
 
Program While1;
 
var
    num: integer;
 
begin
    writeLn('Dime numeros y te dire su doble. Usa 0 para terminar.');
    write( 'Primer numero? ' );
    readLn( num );
    while num <> 0 do
    begin
        writeLn( 'Su doble es ', num*2 );
        write( 'Siguiente numero? ' );
        readLn( num )
    end
end. 

En el ejemplo anterior, sólo se entra al bloque begin-end (una sentencia compuesta) si el primer número es correcto (no es cero). Entonces se escribe su doble, se pide el siguiente número y vuelve a comprobar que sea correcto.

Si ya de principio la condición es falsa, entonces la sentencia no se ejecuta ninguna vez, como ocurre en este ejemplo:

(* WHILE2.PAS, "while" que no se llega a repetir *)
(* Parte de CUPAS5, por Nacho Cabanes            *)
 
Program While2;
 
begin
    while (2 < 1) do
        writeLn('Dos es menor que uno');
end. 

Repetir... hasta (Repeat)

Si queremos asegurarnos de que el bloque repetitivo se ejecute al menos una vez, deberemos comprobar la condición al final. Para eso tenemos la estructura repeat...until, que se usa así:

repeat
sentencia;
(* ... *) sentencia;
sentencia
until condicion;

Es decir, REPITE un grupo de sentencias HASTA que la condición sea cierta. Cuidado con eso: se trata de un grupo de sentencias, no sólo una, como ocurría en "while", de modo que ahora no necesitaremos "begin" y "end" para crear sentencias compuestas.

El conjunto de sentencias se ejecutará al menos una vez, porque la comprobación se realiza al final.

La condición será la opuesta al caso de usar un while: "mientras sea positivo" es lo mismo que decir "hasta que sea negativo o cero".

Como último detalle, de menor importancia, no hace falta terminar con punto y coma la sentencia que va justo antes de "until", al igual que ocurre con "end".

Un ejemplo clásico del uso de repeat..until es un programa de "clave de acceso", como éste, que iremos mejorando cuando veamos cómo manejar cadenas de texto y formas de "esconder" lo que se teclea, bien cambiando colores o bien escribiendo asteriscos u otras letras en su lugar:

(* REPEAT1.PAS, comprobacion de una clave de acceso *)
(* Parte de CUPAS5, por Nacho Cabanes               *)
 
program Repeat1;
 
var
    ClaveCorrecta, Intento: integer;
 
begin
    ClaveCorrecta := 123;
    repeat
        WriteLn( 'Introduce la clave de acceso...' );
        ReadLn( Intento )
    until Intento = ClaveCorrecta
    (* Aquí iría el resto del programa *)
end. 
 

Estructura Condicional

Los programas tienen que tomar decisiones. Al fin y al cabo, esto es lo que hace particulares a los ordenadores, lo que los diferencia del resto de las máquinas.

IF-THEN-ELSE

Con estas tres palabras claves, se pueden tomar decisiones en tiempo de ejecución sobre prácticamente cualquier condición posible. Veamos un ejemplo:

program leccion6;
const Pi=3.14156;
var
    radio : Integer;
    entrada : char;

begin
   
    write('¿Necesitas calcular la circunferencia? [S/N]:'); readln(entrada);
    if (entrada='s') or (entrada='S') then
    begin
        write('Escribe el radio: '); readln(radio);
        write('La circunferencia es ');
        writeln(2*PI*radio);
    end
    else writeln ('No se ha calculado la circunferencia.');
end.

De este pequeño programa se pueden aprender muchas cosas. Lo primero que llama la atención es:

if (entrada='s') or (entrada='S') then

Lo que hay entre el if y el then es la condición. Si lo lees en español literalmente, significa lo mismo que lo que hay escrito, es decir: Si entrada es igual a s minúscula o entrada es igual a S mayúscula entonces.... Entonces estas aprendiendo también que, en Pascal, la palabra or significa lo mismo que en nuestro lenguaje humano, es una forma de unir dos condiciones.

Como ves, las condiciones están puestas entre paréntesis. Esto es necesario porque en Pascal el operador lógico or tiene mayor prioridad que los operadores relacionales (en este caso el operador de igualdad). Si no se pusieran los paréntesis la primera operación que se trataría de realizar sería la or lógica entre el valor literal 's' y la variable entrada. Además de no ser la expresión que se desea evaluar, se produciría un error sintáctico en tiempo de compilación puesto que se produciría una incompatibilidad de tipos. El primer operador que se evaluaría sería el or lógico por ser el más prioritario de la expresión y devolvería un resultado booleano. A continuación, quedan dos operadores relacionales (igualdad) que al tener la misma prioridad se evaluarían de izquierda a derecha. El primero trataría de comparar la variable entrada de tipo char con el resultado lógico obtenido anteriormente como consecuencia de evaluar el operador or. Estas operaciones entre elementos de distinto tipo no están permitidas en Pascal que es un lenguaje fuertemente 'tipado'. Para evitar este doble problema podemos hacer uso de los paréntesis qu al igual que en matemáticas, en programación el uso de paréntesis determina la prioridad y el orden para realizar las operaciones.

Y por último, lo más interesante de todo, la condición: entrada='s' significa ¿es entrada igual a s?. Fíjate que, para las condiciones, NO usamos :=, sino = a secas. Esto es porque una condición no es lo mismo que una asignación. Ahora no estamos asignando a entrada el valor 's', sino que estamos verificándolo. Es una diferenciación muy importante.

Por supuesto, en Pascal los caracteres y los strings hay que rodearlos siempre con los caracteres ' '. Y las mayúsculas, en los strings y caracteres, no son iguales a las minúsculas (fuera de los strings da igual).

Inmediatamente después tenemos otra sorpresa. ¡Hay un bloque, compuesto por begin y end dentro del bloque principal! Lo que hace este bloque, como estarás suponiendo, es ejecutar lo que hay en su interior si la condición antes propuesta es verdadera. Lo que hay dentro del bloque ya sabes lo que significa.

Inmediatamente después del bloque está esto:

    end
    else writeln ('No se ha calculado la circunferencia.');
end.

Fíjate en dos cosas muy importantes: el end no tiene un punto y coma al final, e inmediatamente después hay un else. ¿Por qué?

Porque el else pertenece todavía a la instrucción if anterior. else significa y si no. Si pusieras un punto y coma detrás del end, obtendrías un error. Siempre ten en cuenta, y para esto sirven los puntos y comas, a que instrucción pertenecen unas y otras cosas. Tener esto claro te evitará muchos fallos en el futuro.

Detrás del else no tenemos un bloque de begin...end. Esto es debido no a que no podamos, sino a que como solo ejecutamos una sola instrucción, no es necesario. Podíamos haber escrito esto y el resultado es el mismo:

    end
    else begin
        writeln ('No se ha calculado la circunferencia.');
    end;
end.

Funciones

Declaración

• Las variables se declaran poniendo el nombre que se desee, dos puntos (no importa si hay espacios o no entre medias), y el tipo de variable. Se termina con un punto y coma (obligatorio). El nombre que se desee puede ser, efectivamente, lo que se quiera, con dos normas básica: debe empezar por una letra, y no contener símbolos. Estos son nombres válidos de variables:

a b c pericoEldeLosPalotes mi_variable a9988 variable2g

Y estas son variables NO válidas:

78s mi-variable

Concretamente, la primera, 78s empieza por un número, por lo tanto producirá un error, y mi-variable contiene el símbolo -, que significa resta, y entonces, como es de esperar, el compilador se confunde y piensa que quieres restar a la variable mi la variable variable.

Lo siguiente interesante es el tipo. Efectivamente, estas variables tienen el tipo Integer. Esto significa, en inglés, entero. Si recuerdas cuando aprendiste matemáticas, el tipo de número enteros es aquel que no tiene decimales, por ejemplo -6, 89, 7878787, etc. Pues esto es lo que significa, aunque con algunas limitaciones. Este tipo de datos no admite decimales. Así que asignar a estas variables un número real, por ejemplo, 6.78, producirá un error en tiempo de compilación.

• Las constantes son una forma eficiente y clara de indicar al compilador que un valor no debería modificarse. Se usa como las variables, con la única diferencia que solo se puede escribir en la constante la primera vez que se declara.

program leccion5;

const

PI = 3.14156;

var

radio : Integer;

begin

write('Escribe el radio: '); readln(radio);

writeln(2*PI*radio);

end.

Como ves, declarar una constante y usarla es muy fácil.

Las constantes pueden contener cualquier tipo de dato, incluso strings o tipos de datos más avanzados como veremos más adelante.

No es posible asignar a una constante el valor de una variable, pues no es posible saber que valor tendrá hasta que el programa se ejecute. Sin embargo, una característica curiosa de las constantes, es que pueden contener un valor consecuencia de hacer operaciones sencillas con otras constantes. Por ejemplo:

const

PI = 3.14156;

PI2 = 2 * PI;

Es una buena idea usar constantes siempre que sea posible.

• Las constantes son sustituidas en tiempo de compilación por su valor declarado, cada vez donde se encuentren usadas. Esto repercute en que el procesador del ordenador no tiene que leer una dirección de memoria, sino que el valor se encuentra directamente empotrado en el código. Gracias a esto, el acceso a constantes es más rápido que el acceso a memoria.

• La organización "array" es, probablemente, la estructura de datos más conocida debido a que en muchos lenguajes es la única disponible explícitamente.

Un "array" es una estructura homogénea que está constituida por componentes del mismo tipo, llamado tipo base.

También se denomina estructura de acceso aleatorio, o acceso directo, porque todos sus componentes pueden seleccionarse arbitrariamente y son igualmente accesibles. Para designar a un componente aislado, el nombre de la estructura se amplía con el llamado índice de selección del componente. El índice debe ser un valor del tipo definido como tipo índice del array.

La definición de un tipo "array" T especifica un tipo base To y un tipo índice I.

TYPE      T = ARRAY [ I ]      OF  To

Ejemplos:

TYPE vector = ARRAY [1..3] OF REAL
TYPE linea = ARRAY [1..80] OF CHAR

TYPE nombre = ARRAY [1..32] OF CHAR

Los índices de un "array" deben ser de tipo ordinal. No suele ser posible utilizar el tipo INTEGER porque se excedería el espacio de memoria accesible. Para usar valores enteros como índices, hay que indicar un subrango de enteros.

Un valor de tipo "array" se puede designar por un constructor donde se indica el nombre del tipo y valores constantes de los componentes separados por comas y encerrados entre paréntesis.

     Ejemplo:             vector (2.57, 3.14, -8.16)

Para especificar un mismo valor a componentes consecutivos, se puede usar un factor de repetición de la forma "n of valor"; donde "n" indica el número de componentes que recibirán el mismo valor, y debe ser una expresión constante de tipo INTEGER. El "valor" puede ser una constante u otro constructor del mismo tipo que el componente.

Ejemplos:             vector (3 OF 1.0) es equivalente a vector (1.0,1.0,1.0)

vector (7.2, 2 OF 3.0)

Para seleccionar un componente individual de un "array" se usa un selector que consiste en escribir el nombre de la variable de tipo "array" seguido por el nombre correspondiente al componente, escrito entre corchetes.

Ejemplo:                  si v := vector (2.57, 3.14, -8.16)

entonces v [1] es igual a 2.57.

Los componentes de un "array" se pueden someter a todas las operaciones permitidas para su tipo. La única operación definida para el "array" como tal, es la asignación ( := ).

La forma habitual de operar con "arrays" es actualizar componentes aislados.

El hecho de que los índices tengan que ser de un tipo de datos definido tiene una consecuencia importante: los índices pueden calcularse, es decir, puede ponerse una expresión en lugar de una constante. La expresión debe evaluarse y su resultado determina el componente seleccionado. Esta generalización proporciona una herramienta de programación potente pero, al mismo tiempo, da ocasión a uno de los errores de programación más frecuentes: el valor resultante puede estar fuera del intervalo especificado como campo de variación de los índices. Se supone que en tales casos, la implementación en un equipo concreto ha previsto la emisión de mensajes de error.

Los valores organizados en forma de "array" se suelen manejar utilizando índices variables y sentencias repetitivas que permiten construir algoritmos para realizar tratamientos sistemáticos.

Los índices son de tipo escalar, es decir, un tipo no estructurado en el que está definida una relación de orden. Si el tipo base también está ordenado, entonces queda establecida una relación de orden para ese tipo "array".

La relación de orden entre dos "arrays" está determinada por los dos componentes desiguales, correspondientes, con menor índice.

Invocación

Para invocar a un procedimiento, la sintaxis es:

<nombre_de_procedimiento> (parámetros_actuales) ;

donde la existencia de parámetros_actuales dependerá de que en la declaración del procedimiento se hayan utilizado parámetros formales.

Para ejemplificar el uso de procedimientos, diseñaremos un programa que resuelva el problema de SUMAR Y MULTIPLICAR MATRICES.

PSEUDOCÓDIGO

{PROGRAMA PARA SUMAR Y MULTIPLICAR MATRICES}

INICIO

  IMPRIME encabezado.

  LEE las dimensiones de las matrices A y B.

  SI las matrices no son compatibles para la suma, 

  ENTONCES

    IMPRIME mensaje_1.

  SI las matrices no son compatibles para la mult., 

  ENTONCES

    IMPRIME mensaje_2.

  SI son compatibles para la suma o para la mult. , 

  ENTONCES

    INICIO

      LEE las matrices A y B.

      IMPRIME las matrices A y B.

      SI son compatibles para la suma, ENTONCES

        INICIO

          SUMA las matrices A y B.

          IMPRIMEla matriz resultado C.

        FIN

      SI son compatibles para la multiplicacion, ENTONCES

        INICIO

          MULTIPLICA las matrices A y B.

          IMPRIME la matriz resultado D.

        FIN

    FIN

FIN.

Implementación

- (Esta sección es estrictamente privada y por tanto su contenido no puede ser visto desde el exterior de la unidad)

 - (Esta seccion contiene los cuerpos de los procedimientos y funciones declarados en la seccion "Interface")

- (Las variables declaradas dentro de esta sección serán de uso exclusivo para los procedimientos y funciones de dicha unidad)