Anterior | Superior | Siguiente

Guía de referencia básica de Ada 95

Entrada/salida por terminal.

La librería Text_IO.

Las operaciones básicas de entrada/salida de Ada se encuentran definidas en la librería estándar Text_IO que habrá que incluir en la cláusula de contexto de una unidad de programa que pretenda usarlas:

with Text_Io;
use Text_Io;

Una vez hecho esto, se pueden emplear las operaciones básicas de entrada salida sobre elementos de tipo character y de tipo string (ristras de tamaño fijo).

También se puede realizar entrada/salida de valores del tipo predefinido Integer y sus subtipos usando el paquete Ada.Integer_Text_IO; y del tipo predefinido Float y sus subtipos usando el paquete  Ada.Float_Text_Io .

with Ada.Integer_Text_Io, Ada.Float_Text_Io;
use Ada.Integer_Text_Io, Ada.Float_Text_Io;

Para poder realizar operaciones de entrada/salida con elementos de tipos numéricos distintos del Integer y el Float y sus subtipos, o de tipos  enumerados, se deberá instanciar el que corresponda de entre los seis paquetes genéricos de entrada/salida contenidos en la librería Tex_IO, usando como parámetro el nombre del tipo.

package Día_IO is new Enumeration_IO(Día);      --Enumeration_IO sirve para tipos enumerados
package MiEntero_IO is new Integer_IO(MiEntero);-- Integer_IO sirve para enteros con signo
package Natural_IO is new Modular_IO(Natural);  -- Modular_IO sirve para enteros sin signo
package rf_IO is newFloat_IO(rf);               -- Float_IO sirve para reales en coma flotante
package rfija1_IO is new Fixed_IO(rfija1);      --Fixed_IO sirve para reales en coma fija ordinarios
package rfija2_IO is new Decimal_IO(rfija2);    -- Decimal_IO sirve para reales en coma fija decimales

Si en un programa se utilizan subtipos, basta instanciar el paquete adecuado para el tipo base de los mismos, lo que permitirá usar las operaciones de entrada/salida tanto con éste como con todos sus subtipos.

Operaciones de entrada/salida.

Estructura de la entrada.

La comunicación entre un programa y la terminal no es directa: las teclas pulsadas por el usuario van acumulándose en un "buffer" de entrada formando una secuencia jalonada por marcas de fin de línea (que se generan cuando se pulsa la tecla de retorno) entre otras marcas. Cuando se ejecuta una operación de entrada, ésta toma los caracteres del principio de dicha secuencia, hasta completar un valor del tipo requerido.Un usuario puede teclear antes de que el programa ejecute una instrucción de entrada. Una operación de entrada puede no consumir toda la entrada pendiente, en consecuencia la siguiente no tiene porqué esperar a que el usuario teclee nuevos datos. El programa tan sólo se detendrá en una operación de entrada cuando el "buffer" de entrada esté vacío o no tenga suficientes caracteres para completar el valor requerido, según el tipo de operación.

                         ___________entrada____________
Operaciones de entrada << A 11<eol>pedro<eol> xY23<eol> << Teclado (dispositivo de entrada)
                         ------------------------------

Operaciones básicas de entrada.

Las operaciones básicas de entrada son Get y Get_Line, para leer información, y skip_line para saltar finales de línea.

get(c);

Si c es de tipo character (1), el primer carácter disponible en la entrada se carga en c, a menos que se trate de un fin de línea o fin de página, en cuyo caso se saltarán todas las marcas que se encuentren hasta encontrar un carácter válido.

Si c esde tipo string (2), se realizan tantas llamadas a la versión de get para caracteres como sea necesario para completar el tamaño de c.

Si c es de un tipo númerico (3 ), (4), ( 5), (6), ( 7), se saltan los caracteres de control y los espacios que haya en la entrada, a partir de ahí se lee en c mientras la secuencia de caracteres encontrados pueda interpretarse como un valor numérico del tipo apropiado. Si lo que se encuentra, tras saltar los caracteres de control y espacios, no se puede interpretar de forma adecuada se produce un error.

Si c es de tipo enumerado (8), se actúa igual que en el caso anterior, sólo que lo que se encuentre ha de ser una palabra que corresponda con uno de los valores enumerados del tipo (si bien no importa que esté en mayúsculas o minúsculas).

get_line(s,l);

Donde s es de tipo string y l es de tipo natural ( 9). Lee la string s e informa en l de qué posición ocupa en s el último carácter leído. La lectura termina cuando se alcanza un final de línea o cuando se han leído tantos caracteres como el tamaño definido para s en su declaración. Si se encuentra un final de línea antes de haber completado el tamaño de s, se termina la lectura, se avanza la entrada hasta el principio de la siguiente línea, l tendrá un valor menor que el límite superior del rango de índices de s (acorde con los carácteres leídos) y la subristra de s comprendida entre la posición siguiente a l y el final conservará los valores que tenía antes de la ejecución del get_line . Si se completa el tamañode s, l tomará un valor igual al límite superior del rango de índices de s y no se produce ningún avance a la siguiente línea. Si no se lee ningún carácter (el primer carácter de la entrada es un final de línea), l tomara el valor inmediatamente menor al límite inferior del rango de índices de s y la entrada avanza hasta la el comienzo de la siguiente línea sin que el valor de s varíe.

skip_line;

Sirve para avanzar la entrada hasta el comienzo de la siguiente línea, desechando el resto de la actual ( 10 ).

La operación skip_line admite un parámetro que permite indicar cuantas líneas hay que saltar. Así "skip_line(5);" significa repetir 5 veces "skip_line;".

Cuando se ejecuta un get que consume los caracteres válidos de una línea y la siguiente instrucción de entrada/salida en ejecutarse es un get_line, esta última no leerá nada, ya que encontrará directamente el final de línea. El problema se soluciona poniendo un skip_line detrás del get.

Ocurre un problema parecido cuando se ejecuta un get_line en el que se consigue leer todo el tamaño de la ristra implicada, no pasándose por tanto a la siguiente, y a continuación se va a ejecutar otro get_line . Si se quiere que el segundo get_line empiece a leer en la siguiente línea habrá que ejecutar un skip_line , pero sólo después de verificar el resultado del primero.

Operaciones básicas de salida.

Las operaciones básicas de salida son put ( 11), ( 12), ( 12), ( 13), ( 14), ( 15), ( 16), ( 17 ) y put_line (18 ), para escribir información, y new_line ( 19) para cambiar de línea.

put(x);

Para x de cualquier tipo escalar o de tipo string muestra una secuencia de caracteres que representa el valor de x.

new_line;

Genera un salto de línea. La salida continúa al principio de la siguiente línea.

Al igual que skip_line, admite un parámetro que permite saltar varias líneas.

put_line(s);

Exclusivamente para s de tipo string, equivale a: "put(s); new_line; ".

Opciones adicionales

Parámetros adicionales en las operaciones get.

La operación get admite, para los tipos numéricos (20), (21), (22), (23), (24), un segundo parámetro que permite definir el "ancho de campo" que se va a considerar a la hora de leer el valor de la entrada. Esto significa que no se continuará leyendo mientras la secuencia de caracteres encontrada pueda interpretarse como un valor del tipo adecuado, sino sólo, y exactamente, hasta que se hayan leído tantos caracteres como indique ese parámetro.

entrada=123456789<eol>, x : integer, get(x) => x = 123456789, entrada=<eol>
entrada=123456789<eol>, x : integer, get(x,4) => x = 1234, entrada=56789<eol>

Otras operaciones de entrada.

Si se quiere saber cúal es el siguiente carácter que toca leer, pero sin quitarlo del buffer de entrada, se puede utilizar la operación look_ahead ( 25).

look_ahead(c,fin)

Si el siguiente carácter es un final de línea: fin tiene el valor true y c está indefinido; en caso contrario: fin tiene el valor false y c el del primer carácter del buffer de entrada.

Las operaciones de entrada corrientes toman los caracteres del buffer de entrada y los caracteres tecleados sólo pasan al mismo cuando se pulsa la tecla de retorno, dando así la oportunidad de hacer correcciones, pero en algunas aplicaciones es necesario leer directamentela la tecla pulsada, sin esperar la confirmación que supone la de retorno. Esto puede hacerse con la operación get_inmediate ( 26), que tiene dos versiones.

get_immediate(c)

Pone en c el carácter correspondiente a la primera tecla que se pulse.

get_inmediate(c,e)

Si hay una tecla pulsada: pone en c el carácter correspondiente y e toma el valor true; en caso contrario: e toma el valor false y c queda indefinido.

Parámetros adicionales en la operación put.

Para los tipos enteros, put admite un segundo parámetro, width, que especifica el ancho del campo (número de caracteres) utilizado para escribir el número. Si el valor de este parámetro es mayor que el número de caracteres necesario para escribir el valor, se añadirán espacios por la izquierda. Si es menor se utilizará justo la cantidad que se necesite.

Para los tipos reales, se pueden añadir a put tres parámetros: fore, aft y exp. El primero determina el número de caracteres a usar para la parte entera (incluyendo el punto decimal y el signo si es negativo), el segundo fija el número de caracteres de la parte decimal y el tercero el del exponente. Si el valor de fore es mayor de lo requerido, se insertan espacios por la izquierda, y si es menor se usa lo necesario. Un valor de exp igual a cero causa que la salida se muestre en notación decimal sin exponente.Varias posibles combinaciones se muestran en el siguiente ejemplo.

R: Float:=Ada.Numerics.Pi;
Put(R);                                3.14159E+00
Put(R,Fore => 5);                         3.14159E+00
Put(R,Fore => 5,Aft => 2);                3.14E+00
Put(R,Exp => 1);                       3.14159E+0
Put(R,Fore => 5,Exp => 0);                3.14159
Put(R,Fore => 5,Aft => 2, Exp => 0);      3.14
Put(R,Fore => 5,Aft => 0, Exp => 0);      3.1
Put(-R,Fore => 0,Aft => 0, Exp => 0); -3.1
Put(-R,Fore => 0,Aft => 0);           -3.1E+00
Put(-R,Fore => 0,Aft => 10);          -3.1415927410E+00

© Grupo de Estructuras de Datos y Lingüística Computacional - ULPGC

Anterior | Superior | Siguiente