Sesin 0

Titulación: Ingeniero Técnico Industrial Eléctrico.
Asignatura: Fundamentos de Informática.
Curso: 06-07
Práctica 0
Práctica 0. Ejercicios con el editor, el compilador y el depurador (2 sesiones)
Primeros Pasos
Los siguientes tres pasos tendrás que hacerlos todos los días que trabajemos en el laboratorio, al comienzo, para poder
arrancar el compilador de Turbo Pascal.
1.
2.
3.
Entrar al ordenador con el nombre de usuario Labora3 y la contraseña Labora3.
En el escritorio hay una carpeta llamada ‘Programas Labora 3’, y dentro de ella un acceso directo al compilador de
Turbo Pascal. Haz doble clic en ese icono para abrir el programa.
Se abre una ventana azul, que es el editor-compilador con el que vamos a trabajar.
Programar
1.
Para empezar a trabajar con el editor, vamos a copiar el programa ‘divreal’, cuyo código en Pascal tienes a
continuación, en el editor de Turbo Pascal, en la ventana azul que se ha abierto en el paso anterior. Los números
de línea son meramente informativos, no los escribas. Todo lo que está escrito entre los símbolos (* y *) son
comentarios para que puedas entender mejor lo qué hace el programa en cada línea; por lo tanto, no hace falta que los
copies en el editor.
1)
PROGRAM divreal; (*cabecera del programa*)
2)
3)
(* Nombre y apellidos del autor (Por ejemplo: Silvia Sanz Santamaría) *)
(* Fecha de realización (Por ejemplo: 16-10-06) *)
4)
5)
6)
7)
(* Especificación *)
(* Entrada: dividendo y divisor, números reales, operadores de la división *)
(* Salida: division, número real, resultado de la división de las variables de entrada *)
(* Función: Solicitar al usuario los valores del dividendo y el divisor, calcular su división y *)
(* escribirla por pantalla *)
8) VAR (*declaración de variables*)
9)
dividendo, divisor, division: integer; (*números enteros*)
10)
res: char; (*letra; recoge la intención del usuario de continuar*)
11) BEGIN (*comienza el cuerpo del programa*)
12)
REPEAT (*instrucción para repetir el conjunto de instrucciones que están debajo (hasta UNTIL)*)
13)
write (‘Dame el dividendo: ‘); (*escribe por pantalla esa frase*)
14)
readln (dividendo); (*almacena en la variable dividendo el nº que pulsa el usuario*)
15)
write (‘Dame el divisor: ‘); (*escribe por pantalla esa frase*)
16)
readln (divisor); (*almacena en la variable divisor el nº que pulsa el usuario*)
17)
division := dividendo div divisor; (*almacena en la variable division el resultado de dividir el*)
(*nº que hay en la variable dividendo entre el nº que hay*)
(*almacenado en la variable divisor*)
18)
write (‘El resultado de dividir ‘, dividendo); (*escribe por pantalla la frase y el valor de la vble. dividendo*)
19)
writeln (‘entre ‘, divisor, ‘ es ‘, division); (*escribe por pantalla las palabras y los valores de las vbles.*)
20)
writeln (‘Deseas continuar (s/n)?’); (*escribe por pantalla la frase*)
21)
readln (res); (*almacena en la variable. res el valor que introduce el usuario por el teclado*)
22)
UNTIL res <> ‘s’; (*si el valor de la variable res es la letra s se acaba la repetición, si no, se vuelve*)
(*a REPEAT y se ejecutan otra vez todas las instrucciones*)
23)
readln; (*para poder ver los resultados en pantalla antes de que finalice la ejecución*)
24) END. (*fin del programa*)
1
Titulación: Ingeniero Técnico Industrial Eléctrico.
Asignatura: Fundamentos de Informática.
Curso: 06-07
Práctica 0
La línea 1 se denomina cabecera, e indica que comienza un programa, en este caso llamado divreal. Las líneas
2 y 3 identifican al autor y fecha de creación del programa; ponlas en todos los programas que quieras entregarme.
Las líneas 4 a 7 son la especificación del programa; ponlas en todos los programas cuyo código pueda leer
alguien. Las líneas 8 a 10 son la declaración de variables (fijaos que la de la línea 10 incluye una explicación de su
cometido; en las anteriores no es necesario pues ya se explica en la especificación). La línea 11 indica el principio
de las instrucciones ejecutables, lo que denominamos cuerpo del programa. Las líneas 12 y de 20 a 22
permiten la ejecución repetitiva del programa. Te permitirán ahorrar tiempo en estos programas de prueba. Las
líneas 13 a 19 son instrucciones en Pascal que van a permitir hacer la división de dos números enteros introducidos por
el teclado y ver el resultado en la pantalla: las líneas 13 a 16 son las de entrada de datos; la 17 es el cálculo de la
división y la 18 y 19 muestran el resultado. La línea 23 sirve para poder visualizar los resultados del programa en
la ventana de ejecución, ya que si no pones esta instrucción, se ejecuta el programa, se escriben los datos y
rápidamente se cierra la ventana de ejecución sin que puedas ver los resultados (pruébalo!!). La línea 24 indica el
final del programa.
Compilar
1.
2.
3.
Una vez tecleado el programa, pasamos a compilarlo. Esto significa que el compilador de Turbo Pascal examina el
programa para detectar posibles errores de sintaxis. En el menú de la parte superior del programa (File, Edit,...)
pincha en la opción Compile y en el menú que se despliega, la opción Compile. También es posible hacer esto
directamente con las teclas Alt+F9. Compila el programa divreal que acabas de escribir.
Si el programa tiene algún error, irán apareciendo mensajes en la parte superior de la pantalla que te indicarán qué
tipo de error se ha producido y en qué línea. Lee atentamente los mensajes y corrige los errores. Para saber si se
han solventado, vuelve a compilar el programa (Alt+F9).
Si el programa no tiene errores sintácticos aparecerá una ventana comentándolo y diciendo que pulses cualquier
tecla para continuar (Press any key to continue). Ahora estarás en disposición de ejecutar el programa.
Ejecutar
1.
2.
3.
Para ejecutar el programa es indispensable que previamente se haya compilado sin errores.
Igual que para compilar, podemos ejecutar de dos formas: bien mediante el menú pulsando Run y en el menú
desplegable pinchando en Run, o mediante las teclas de acceso directo Control+F9.
Al ejecutar un programa, se abre una pequeña ventana negra donde se visualiza dicha ejecución. Ahí es donde
debes introducir los datos, si es que se piden, y donde verás los resultados. Ejecuta el programa divreal con los
datos 7 y 4, y observa lo que ocurre. Vuelve a ejecutar con los datos 1 y 0, ¿qué pasa ahora?.
NOTA: para volver al editor después de la ejecución, pulsa Intro.
El Depurador
El Depurador (debugger) es una utilidad que sirve para ver los valores que van tomando las varibles en los diferentes
momentos de la ejecución. Vamos a probarlo con el siguiente programa, que no hace nada en concreto, sólo es para
observar con claridad la función del debugger. Escribe el programa en el editor de Turbo Pascal y compílalo hasta que no
tenga errores.
PROGRAM prueba_debugger;
VAR
a, b, c: integer;
BEGIN
a:=2;
b:=3;
c:= a+b;
a:=a-1;
c:=c*2;
writeln (a, ‘ ‘, b, ‘ ‘, c);
END.
Generalmente, el depurador se utiliza de dos formas: (1) cuando el programa es corto, se puede ejecutar cada instrucción
2
Titulación: Ingeniero Técnico Industrial Eléctrico.
Asignatura: Fundamentos de Informática.
Curso: 06-07
Práctica 0
una a una y ver qué cambios se van produciendo en los valores de las variables en cada paso; (2) si el programa es largo,
o hay alguna parte de él en la que no nos interesa visualizar los valores de las variables, se utilizan los puntos de ruptura
(breackpoints).
Un breackpoint se puede colocar en cualquiera de las instrucciones del cuerpo del programa, y sirve para ejecutar todas las
intrucciones anteriores a ese punto de forma continua y parar la ejecución justo en el punto de ruptura para ver la situación
de las variables hasta ese momento. Sigue los siguientes pasos para ver estos dos tipos de ejecución.
1.
2.
3.
4.
Para poder visualizar el valor de las variables, hay que añadir esas variables en el debugger. Para ello, pincha en
el menú Debug, en el menú que se despliega en Watches y en el siguiente menú en Add Watch. En la ventanita
que aparece, escribe el nombre de la variable que quieres visualizar y pulsa OK. Sabrás que has añadido esa
variable porque aparecerá en la parte inferior del editor, en una ventana de color verdoso (ventanta de watches). Si
no aparece esa ventana de color verdoso, pincha en el menú Window de la parte superior del editor y en el menú
que se despliega en Watch.
Otro modo de añadir las variables es colocándote sobre ellas y siguiendo los pasos anteriores, con lo que evitas
escribirla, ya que aparece automáticamente y solo tienes que pulsar OK.
Repite este paso, de un modo u otro, tantas veces como variables quieras visualizar.
Para borrar una variable de la ventana de watches, selecciona dicha variable en la ventana de watches (pincha
sobre ella), pincha en el menú Debug, en el menú que se despliega en Watch y después en Delete watch. Si todo
ha ido bien, la variable ya no estará en la ventana de watches.
Ejecución paso a paso (instrucción a instrucción): una vez añadidas las variables, vamos a ver cómo cambian de
valor conforme se van ejecutando las intrucciones. Para ello, pincha en el menú Run y en el menú que se
despliega en Step Over. Esto hace que se ponga en marcha la ejecución y se ejecute la primera línea.
En cada momento, puedes saber qué línea se está ejecutando porque aparece resaltada con una franja en el
editor.
Para ejecutar la siguiente instrucción, pulsa F8, y observa cómo va cambiando el valor de las variables en la
ventana de watches. ¿Funciona correctamente?.
Pulsa F8 y observa los cambios de valor de las variables sucesivamente hasta llegar a la última instrucción (END.).
Ejecución con puntos de ruptura: vamos a insertar dos puntos de ruptura, uno el la instrucción a:=a-1; y otro en la
instrucción writeln (a, ‘ ‘, b, ‘ ‘, c);. Para insertar un breackpoint, coloca el cursor del editor en la instrucción donde
quieres insertar el punto de ruptura, pulsa en el menú Debug, en el menú que se despliega pincha en Breackpoint;
aparece una ventanita, pincha en Edit, introduce en la última casilla el número de línea que ocupa la instrucción
donde quieres poner el breckpoint (aparece en la parte inferior izquierda del editor) y pulsa New. Si lo has hecho
bien, la línea donde has insertado el breackpoint aparecerá en el editor resaltada en rojo. Hay que hacer estos
pasos para cada punto de ruptura que se quiera poner.
Para quitar un punto de ruptura basta con situarse en el editor, pulsar en el menú Debug y en el menú que se
despliega en Toggle Breackpoint. Si lo has quitado correctamente, esa línea dejará de estar resaltada.
Una vez colocados los puntos de ruptura, vamos a ejecutar el programa. Para ello, pulsa Control+F9, y se
ejecutarán todas las instrucciones hasta el primer punto de ruptura, sin incluir éste. Es decir, en nuestro caso, se
ejecutarán las instrucciones a:=2; b:=3; c:=a+b;. Observa que los valores de las variables en la ventana de
watches han cabiado conforme a esta ejecución. Para continuar hasta el siguiente breackpoint, pulsa de nuevo
Control+F9. La ejecución parará en la instrucción writeln (a, ‘ ‘, b, ‘ ‘, c);. Observa los valores de las variables. ¿Son
correctos?. Para seguir con la ejecución, hay que pulsar otra vez Control+F9, que en este caso finalizará la
ejecución del programa porque ya no hay más puntos de ruptura.
Para finalizar
Para acabar con esta práctica y especialmente con las que iremos desarrollando en los próximos laboratorios, es muy
recomendable que guardes los programas que implementes en un dispositivo de almacenamiento portátil (disquete, usb,
etc.), puesto que esta sala la usan muchos alumnos y si los guardas sólo en el ordenador, podrías perder todo el trabajo
hecho.
Para guardar los programas en un disquete, pincha en el menú File y en el menú que se despliega en Save file as. Aparece
una ventanita donde debes poner a:\nombredelprograma.pas y pulsar OK. El nombre del programa puede tener como
máximo 8 caracteres.
Por defecto, es decir, si pulsas Save file as y sin hacer nada más pulsas OK, el fichero con el programa desarrollado se
guardará en el directorio D:\Archivos de Programa\TP. Puedes ir a buscar el fichero a ese directorio y guardarlo luego en el
disquete o usb, arrastrándolo o usando el botón derecho del ratón.
3