Acciones básicas
A lo largo de la primera parte del curso, hemos estado hablando
de algoritmos, funciones, procedimientos, estructuras repetitivas,
y otras cosas no menos importantes para escribir un programa.
Sin embargo, una acción muy común cuando uno se enfrenta
con una máquina es coger el teclado y ponerse a escribir.
Paralelamente, uno se espera que lo que escribe vaya apareciendo por la
pantalla.
Cuando alguien realiza un programa, lo más normal es que vaya a
interactuar con el usuario de alguna manera, bien pidiendo datos,
bien mostrando paso a paso los resultados de un cierto proceso,
o bien leyendo la posición del puntero del ratón para ir
dibujando puntos...
Lógicamente, querremos que los resultados de una entrada del
usuario vayan a parar a algunas variables que nosotros habremos
dispuesto para luego operar con ellas.
Luego, podremos querer mostrar por pantalla el resultado de una
acción, que tendremos almacenado en alguna variable, para que
el usuario pueda comprobar valores, usarlos posteriormente, etc...
Y en todo lo que hemos visto anteriormente, sólo muy de pasada,
hemos visto cómo podíamos llevar a cabo estas operaciones
básicas de entrada/salida.
El nombre, formato, etc., depende del lenguaje escogido; sin
embargo, todas tienen algo en común, y eso es lo que vamos a
describir ahora.
Tenemos tres acciones básicas: asignación,
lectura (o entrada) y escritura (o
salida). De la asignación ya hablamos en el tema de
las variables.
Acciones de lectura
Las acciones de entrada nos permiten obtener determinados valores
a partir de un periférico (teclado, ratón, un fichero...)
y ASIGNARLOS a unas determinadas variables.
Cuando escribimos un algoritmo, la acción de lectura se
escribe:
leer de (periferico) (lista de variables de entrada)
Por ejemplo:
leer de teclado (x,y,z)
Si ahora el usuario introduce los números 20, 10, 12,
automáticamente se habrán realizado las acciones de
asignación:
x <- 20
y <- 10
z <- 12
Acciones de escritura
Las acciones de salida permiten transferir a un periférico
(pantalla, un fichero, impresora, ...) resultados obtenidos por la
máquina. En un algoritmo, esta acción la pondremos de
la siguiente forma:
mostrar por (periférico) (lista de variables de salida)
Por ejemplo, tras hacer:
A <- 100
B <- 101
C <- 99
si en nuestro algoritmo pone:
mostrar por impresora (A,B,C)
nuestra impresora se pondrá en marcha y nos sacará
los valores 100, 101, 99
Una pequeña PostData
PD: Existe una estructura de salto incondicional, se llama GOTO,
y tiene la forma
GOTO etiqueta
donde etiqueta es un nombre que nosotros elijamos como
referencia. Usualmente van seguidas de : para saber que se
trata de una etiqueta y no una variable (por ejemplo) NO declarada.
El funcionamiento es bien sencillo: en cuanto llegamos al GOTO,
el flujo del programa automáticamente da un salto a la zona
especificada a partir de la etiqueta.
Su uso no es nada recomendado por varios motivos: dificulta la
lectura del programa y pueden descontrolarse muy fácilmente si no
se les sigue bien la pista. Lo que se puede hacer un GOTO se
puede hacer con las otras estructuras que hemos visto.
Por ejemplo:
i <- 0
suma <- 0
saltar:
suma <- suma + i
si (i<10) entonces hacer
i <- i+1
GOTO saltar
fin si
puede hacerse también así:
suma <- 0
desde <-0 mientras i<10 hacer
suma <- suma+i
fin desde
Mucho más compacto y menos engorroso.
Sin embargo, podemos estar en un bucle demasiado anidado y quizá
en algún momento el programa tenga un parón
crítico y haya que salir de ese bucle como sea: quizá
ese momento sea el único en que el GOTO nos pueda salvar, pero
salvo en algo muy crítico, lo mejor es evitarlo. Me refiero
en lenguajes de alto nivel, claro O:-D ....
Tutoriales
