Tema 3: Entrada/salida básica

Curso: Curso de Pascal, por Nacho Cabanes

Tema 3: Entrada/salida básica.

Ya hemos visto por encima las dos formas más habituales de mostrar datos en pantalla, con "write" o "writeln", y de aceptar la introducción de datos por parte del usuario, con "readln" (o "read", que no efectúa un retorno de carro después de leer los datos). Veamos ahora su manejo y algunas de sus posibilidades con más detalle:

Para mostrar datos, tanto en pantalla como en impresora, se emplean write y writeln. La diferencia entre ambos es que "write" deja el cursor en la misma línea, a continuación del texto escrito, mientras que "writeln" baja a la línea inferior. Ambas órdenes pueden escribir tipos casi de cualquier clase: cadenas de texto, números enteros o reales, etc. No podremos escribir directamente arrays, records, ni muchos de los datos definidos por el usuario.

Cuando se desee escribir varias cosas en la misma línea, todas ellas se indican entre un mismo paréntesis, y separadas por comas.

Un comentario para quien ya haya programado en Basic: en la mayoría de las versiones de este lenguaje si separamos varios datos mediante comas en una sentencia PRINT, se verán separados en pantalla por un cierto número de espacios. En ese aspecto, la "," de Pascal recuerda más al ";" de Basic, ya que escribe los datos uno a continuación del otro. De hecho, si fueran números, ni siquiera aparecerían espacios entre ellos (también al contrario que en la mayoría de versiones de Basic):

WriteLn (1,10,345);

daría como resultado

110345

Se puede especificar la anchura de lo escrito, mediante el símbolo de dos puntos (:) y la cifra que indique la anchura. Si se trata de un número real y queremos indicar también el número de decimales, esto se hace también después de los dos puntos, con el formato ":anchura_total:decimales". Como ejemplos:

program Write1;

var
  nombre: string[40];
  edad: byte;
  resultado: real;

begin
  nombre := 'Pepe';
  edad := 18;
  resultado := 13.12;
  write ('Hola, ',nombre,' ¿qué tal estás? ');
  writeln (resultado:5:2);
  writeln('Hola,',nombre:10,'.  Tu edad es: ',edad:2);
end.

En el caso de una cadena de texto, la anchura que se indica es la que se tomará como mínima: si el texto es mayor no se "parte", pero si es menor, se rellena con espacios por la izquierda hasta completar la anchura deseada.

Tema 3.2: Anchura de presentación en los números.

Igual ocurre con los números: si es más grande que la anchura indicada, no se "parte", sino que se escribe completo. Si es menor, se rellena con espacios por la izquierda. Los decimales sí que se redondean al número de posiciones indicado:

program Write2;

var num: real;
begin
  num := 1234567.89;
  writeln(num);
    (* La línea anterior lo escribe con el formato por defecto:
     exponencial *)
  writeln(num:20:3);  (* Con tres decimales *)
  writeln(num:7:2);   (* Con dos decimales *)
  writeln(num:4:1);   (* Con un decimal *)
  writeln(num:3:0);   (* Sin decimales *)
  writeln(num:5);     (* ¿Qué hará ahora? *)
end.

La salida por pantalla de este programa sería:

1.2345678900E+06
1234567.890
1234567.89
1234567.9
1234568
1.2E+06

Aquí se puede observar lo que ocurre en los distintos casos:

Si no indicamos formato, se usa notación científica (exponencial).
Si la anchura es mayor, añade espacios por la izquierda.
Si es menor, no se trunca el número.
Si el número de decimales es mayor, se añaden ceros.
Si éste es menor, se redondea.
Si indicamos formato pero no decimales, sigue usando notación exponencial, pero lo más compacta que pueda, tratando de llegar al tamaño que le indicamos.

Tema 3.3: Comentarios.

En este programa ha aparecido también otra cosa nueva: los comentarios:

writeln(num:20:3);  (* Con tres decimales *)

Un comentario es algo el compilador va a ignorar, como si no hubiéramos escrito nada, y que nosotros incluimos dentro del programa para que nos resulte más legible o para aclarar lo que hace una línea o un conjunto de líneas.

En Pascal, los comentarios se encierran entre (* y *). También está permitido usar { y }, tanto en Turbo Pascal como en SURPAS. Como se ve en el ejemplo, los comentarios pueden ocupar más de una línea.

A partir de ahora, yo emplearé los comentarios para ayudar a que se entienda un poco más el desarrollo del programa, y también para incluir una cabecera al principio, que indique el cometido del programa y los compiladores con los que ha sido comprobado.

En la práctica, es muy importante que un programa esté bien documentado. Cuando se trabaja en grupo, la razón es evidente: a veces es la única forma de que los demás entiendan nuestro trabajo. En estos casos, el tener que dar explicaciones "de palabra" es contraproducente: Se pierde tiempo, las cosas se olvidan... Tampoco es cómodo distribuir las indicaciones en ficheros aparte, que se suelen extraviar en el momento más inoportuno. Lo ideal es que los comentarios aclaratorios estén siempre en el texto de nuestro programa.

Pero es que cuando trabajamos solos también es importante, porque si releemos un programa un mes después de haberlo escrito, lo habitual es que ya no nos acordemos de lo que hacía la variable X, de por qué la habíamos definido como "Record" y no como "Array", por qué dejábamos en blanco la primera ficha o por qué empezábamos a ordenar desde atrás.

Por cierto, que de ahora en adelante, como ya entendemos eso de los comentarios, los usaré para indicar las versiones en las que está comprobado cada uno de los programas, y para explicar un poco lo que hace.

(Nota: según el compilador que manejemos, es habitual que un comentario que empezamos con (* se deba terminar con *), y no con }. También es frecuente que no se puedan "anidar" comentarios, de modo que algo como begin {{} end es correcto, porque la segunda llave abierta se ignora en la mayoría de los compiladores, mientras que algunos exigirán que se cierre también: begin {{}} end Puede incluso que algún compilador nos permita escoger cual de las dos opciones preferimos.

Una observación: si queremos escribir las comillas (o algún símbolo extraño que no aparezca en el teclado) como parte de un texto, podemos hacerlo de varias formas. La forma habitual es conociendo su código ASCII y usando la función CHR. Por ejemplo, el símbolo ~ corresponde al código ASCII 126, de modo que usaríamos “write(chr(126))”. En Turbo Pascal existe también una notación alternativa, que es usar # en vez de CHR, de manera que podríamos escribir “write(#126)”. Y para el caso particular de las comillas, hay una posibilidad extra: si dentro de una orden write ponemos dos comillas seguidas, el compilador entenderá que queremos escribir una de ellas.

Vamos a verlo con un ejemplo:

Ejercicio propuesto: Crea un programa que pida al usuario dos números reales y muestre en pantalla el resultado de su división, con dos cifras decimales.

{--------------------------}
{  Ejemplo en Pascal:      }
{                          }
{    Como escribir las     }
{      comillas            }
{    COMILLA.PAS           }
{                          }
{  Este fuente procede de  }
{  CUPAS, curso de Pascal  }
{  por Nacho Cabanes       }
{                          }
{  Comprobado con:         }
{    - Free Pascal 2.2.0w  }
{    - Turbo Pascal 7.0    }
{    - FPK Pascal 1.0      }
{--------------------------}

program comilla;

begin
  writeln(' writeln(' + chr(39) + 'Esto es un ejemplo' +chr(39) +')');
  writeln(' writeln(' + #39 + 'Esto es un ejemplo' + #39 +')');
  writeln(' writeln(''Esto es un ejemplo'')');
end.

Tema 3.4: Leer datos del usuario.

Para tomar datos del usuario, la forma más directa es empleando readln, que toma un texto o un número y asigna este valor a una variable. No avisa de lo que está haciendo, así que normalmente convendrá escribir antes en pantalla un mensaje que indique al usuario qué esperamos que teclee:

writeln('Por favor, introduzca su nombre');
readln(nombre);

"Readln" tiene algunos inconvenientes:

No termina hasta que pulsemos RETURN.
La edición es incómoda: para corregir un error sólo podemos borrar todo lo que habíamos escrito desde entonces, no podemos usar las flechas o INICIO/FIN para desplazarnos por el texto.
Si queremos dar un valor a una variable numérica y pulsamos " 23" (un espacio delante del número) le dará un valor 0.
...

A pesar de estos inconvenientes, es la forma estándar de leer datos del teclado, así vamos a ver un ejemplo de cómo usarla:

{--------------------------}
{  Ejemplo en Pascal:      }
{                          }
{    Introducción de datos }
{    con ReadLn            }
{    READLN1.PAS           }
{                          }
{  Este fuente procede de  }
{  CUPAS, curso de Pascal  }
{  por Nacho Cabanes       }
{                          }
{  Comprobado con:         }
{    - Free Pascal 2.2.0w  }
{    - Turbo Pascal 7.0    }
{    - Turbo Pascal 5.0    }
{    - Surpas 1.00         }
{--------------------------}

program Readln1;

var
  nombre: string[40];
  edad: byte;

begin
  write ('Escribe tu nombre: ');
  readln(nombre);
  write ('Y ahora tu edad: ');
  readln(edad);
  write ('Hola, ',nombre,' ¿qué tal estás?');
  writeln('Hola,',nombre:10,'.  Tu edad es:',edad:2);
end.

Más adelante, veremos que existen formas mucho más versátiles y cómodas de leer datos a través del teclado, en el mismo tema en el que veamos cómo se maneja la pantalla en modo texto desde Pascal...

Ejercicio propuesto: Crea un programa que pida al usuario su nombre y su apellido y luego los escriba al revés, separados por una coma. Por ejemplo si el usuario introduce Nacho como nombre y Cabanes como apellido, se escribirá Cabanes, Nacho.

Actualizado el: 02-06-2010 11:13

Curso de Pascal, por Nacho Cabanes