Tema 1. Generalidades del Pascal.
Vamos a empezar "al revés" de lo habitual:
veremos un ejemplo de programa básico en Pascal (que se limitará
a escribir la palabra "Hola" en la pantalla) y comentaremos cada una de las
cosas que aparecen en él:
program Saludo;
begin
write('Hola');
end.
Lo primero que llama la atención es que casi todas las palabras están escritas en inglés. Esto será lo habitual: la gran mayoría de las palabras clave de Pascal (palabras con un significado especial dentro del lenguaje) son palabras en inglés o abreviaturas de éstas.
Los colores que se ven en este programa NO aparecerán en cualquier editor que utilicemos. Sólo los editores más modernos usarán distintos colores para ayudarnos a descubrir errores y a identificar mejor cada orden cuando tecleamos nuestros programas.
En el lenguaje Pascal no existe distinción entre mayúsculas y minúsculas, por lo que "BEGIN" haría el mismo efecto que "begin" o "Begin". Así, lo mejor será adoptar el convenio que a cada uno le resulte más legible: algunos autores emplean las órdenes en mayúsculas y el resto en minúsculas,otros todo en minúsculas, otros todo en minúsculas salvo las iniciales de cada palabra... Yo emplearé normalmente minúsculas, y a veces mayúsculas y minúsculas combinadas cuando esto haga más legible algún comando "más enrevesado de lo habitual" (por ejemplo, si están formados por dos o más palabras inglesas como OutText o SetFillStyle.)
Si sabemos un poco de inglés, podríamos traducir literalmente el programa anterior, y así podremos darnos cuenta de lo que hace (aunque en un instante lo veremos con más detalle):
programa saludo
comienzo
escribir 'Hola'
final
Otra cosa que puede extrañar es eso de que algunas líneas terminen con un punto y coma. Pues bien, cada sentencia (u orden) de Pascal debe terminar con un punto y coma (;), salvo el último "end", que lo hará con un punto.
También hay otras tres excepciones: no es necesario un punto y coma después de un "begin", ni antes de una palabra "end" o de un "until" (se verá la función de esta palabra clave más adelante), aunque no es mala técnica terminar siempre cada sentencia con un punto y coma, al menos hasta que se tenga bastante soltura.
Cuando definamos variables, tipos, constantes, etc., veremos que tampoco
se usa punto y coma después de las cabeceras de las declaraciones. Pero
eso ya llegará...
Pues ahora ya sí que vamos a ver con un poco más de detalle lo que hace este programa.
Comienza con la palabra program. Esta palabra no es necesaria en muchos compiladores, como Turbo Pascal o Surpas, pero sí lo era incialmente en Pascal estándar, y el formato era
program NombrePrograma (input, output);(entre paréntesis se escribía "input, output" para indicar que el programa iba a manejar los dispositivos de entrada y salida). Por ejemplo, como este programa escribe en la pantalla, si alguien usa una de las primeras versiones del Pascal de GNU, o algún otro compilador que siga estrictamente el Pascal estándar, deberá poner:
program Saludo(output);Aunque para nosotros no sea necesario, su empleo puede resultar cómodo si se quiere poder recordar el objetivo del programa con sólo un vistazo rápido a su cabecera.
En algunos compiladores, puede que "nos regañe" si la palabra que sigue a "program" es distinta del nombre que tiene el fichero (es el caso de las primeras versiones de Tmt Pascal Lite), pero normalmente el programa funcionará a pesar de ello.
En nuestro caso, a nuestro programa lo hemos llamado "Saludo". La palabra "Saludo" es un identificador. Los "identificadores" son palabras que usaremos para referirnos a una variable, una constante, el nombre de una función o de un procedimiento, etc. Ya iremos viendo todos estos conceptos, pero sí vamos a anticipar un poco uno de ellos: una variable equivale a la clásica incógnita "x" que todos hemos usado en matemáticas (eso espero), que puede tomar cualquier valor. Ahora nuestras "incógnitas" podrán tener cualquier valor (no sólo un número: también podremos guardar textos, fichas sobre personas o libros, etc) y podrán tener nombres más largos (y que expliquen mejor su contenido, no hará falta limitarnos a una única letra, como en el caso de "x").
Estos nombres de "identificadores" serán combinaciones de letras (sin acentos) y números, junto con algunos (pocos) símbolos especiales, como el de subrayado (_). No podrán empezar con un número, sino por un carácter alfabético (A a Z, sin Ñ ni acentos) o un subrayado, y no podrán contener espacios.
Así, serían identificadores correctos: Nombre_De_Programa,
programa2, _SegundoPrograma pero no serían admisibles
2programa, 2ºprog, tal&tal, Prueba de programa, ProgramaParaMí
(unos por empezar por números, otros por tener caracteres no aceptados,
y otros por las dos cosas).
Las palabras "begin" y "end" marcan
el principio y el final del programa, que esta vez sólo se compone
de una línea. Nótese que, como se dijo, el último
"end" debe terminar con un punto.
"Write" es la orden que permite escribir un texto en pantalla. El conjunto de todo lo que se desee escribir se indica entre paréntesis. Cuando se trata de un texto que queremos que aparezca "tal cual", éste se encierra entre comillas (una comilla simple para el principio y otra para el final, como aparece en el ejemplo).
El punto y coma que sigue a la orden "write" no es necesario (va justo antes de un "end"), pero tampoco es un error, y puede ser cómodo, porque si después añadimos otra orden entre "write" y "end", sería dicha orden la que no necesitaría el punto y coma (estaría justo antes de "end"), pero sí que pasaría a requerirlo el "write". Se entiende, ¿verdad? ;)
Para que no quede duda, probad a hacerlo: escribid ese "write" sin punto y coma al final, y vereis que no hay problema. En cambio, si ahora añadís otro "write" después, el compilador sí que protesta.
La orden "write" aparece algo más a la
derecha que el resto. Esto se llama escritura indentada, y consiste
en escribir a la misma altura todos los comandos que se encuentran a un mismo
nivel, algo más a la derecha los que están en un nivel inferior,
y así sucesivamente, buscando mayor legibilidad. Se irá
viendo con más detalle a medida que se avanza.
En un programa en Pascal no hay necesidad de conservar una estructura tal que aparezca cada orden en una línea distinta. Se suele hacer así por claridad, pero realmente son los puntos y coma (cuando son necesarios) lo que indica el final de una orden, por lo que el programa anterior se podría haber escrito:
program Saludo; begin write('Hola'); end.
o bien
program Saludo;
begin write('Hola');
end.
pro gram Saludo;el ordenador creerá que "pro" y "gram" son dos órdenes distintas,
y nos dirá que no sabe qué es eso.
Los detalles concretos sobre cómo probar este programa dependerán
del compilador que se esté utilizando.
Unos tendrán un Entorno Integrado, desde el que escribir los programas
y probarlos (como Free Pascal, Turbo Pascal y Surpas),
mientras que en otros hará falta un editor para teclear los programas
y el compilador para probarlos (como Tmt Lite)
y otros no incluyen editor en la distribución normal, pero es fácil
conseguir uno adaptado para ellos (es el caso de FPK y de Gnu Pascal).
(En un apéndice de este curso tendrás enlaces a sitios donde descargar todos esos compiladores, así como instrucciones para instalarlos).
Nosotros usaremos Free Pascal en la mayoría de los ejemplos de este curso, porque es un compilador gratuito, que sigue bastante el estándar que marcó Turbo Pascal, que funciona bien en ordenadores modernos (Turbo Pascal da problemas en algunos) y que está disponible para distintos sistemas operativos: MsDos, Windows, Linux, etc.
Tienes instrucciones sobre cómo instalar Free Pascal, pero en este momento vamos a suponer que ya está instalado y a ver cómo se teclearía y se probaría este programa bajo Windows:
Al entrar al compilador, nos aparece la pantalla de "bienvenida":
En el menú "File", usamos la opción "New" para comenzar a teclear un nuevo programa
Una vez que esté tecleado, escogemos la opción "Run" del menú "Run" (o pulsamos Ctrl+F9) para probarlo. Si todavía no hemos guardado el fichero, nos pedirá en primer lugar que lo hagamos.
Y ya está listo. Eso sí, posiblemente tendremos un "problema": nuestro programa realmente escribe Hola en nuestra pantalla, pero lo hace muy rápido y vuelve a la pantalla de edición del programa, así que no tenemos tiempo de leerlo. Podemos ver el resultado (la "pantalla de usuario") pulsando las teclas Alt+F5 (o la opción "User Screen" del menú "Debug"). Veremos algo como esto:
Running "c:\leng\pp\bin\go32v2\ej01.exe "
Hola
Si estamos bajo Linux, usaremos cualquiera de los editores del sistema para teclear nuestro programa, lo guardaremos con el nombre "ejemplo.pas", y después teclearemos
fpc ejemplo.pas
Si no hay ningún error, obtendremos un programa "ejecutable", capaz de funcionar por sí solo, y que podremos probar tecleando
./ejemplo
Ejercicio propuesto: Crea un programa similar al primer ejemplo que hemos visto, pero que, en vez de escribir Hola, escriba tu nombre.