Introducción a la programación usando BASIC (IV): Cadenas, GOTO

Artículo publicado en el número 4 de RetroWiki Magazine

CONTROL DEL PROGRAMA Y MANEJO DE CADENAS. EJEMPLO: CALCULADORA

En la entrada anterior presentamos la instrucción básica de control del programa, la sentencia IF condición THEN acción, que junto al uso del GOTO permite realizar cualquier programa, mas adelante usaremos otras sentencias de control, que agilizan el manejo del programa, pero vamos a centrar esta entrada en estas dos, junto con instrucciones de manejo de cadenas, para hacer una nueva versión de la calculadora.

Vamos a hacer una calculadora que nos pregunte que operación deseamos usar, la escribamos en una solo línea, la analice y la ejecute. Así podemos poner “3+2-7” y debe darnos como resultado -2. De momento usaremos solo operaciones sencillas, ya iremos ampliando. Iremos por partes (al final el programa completo)

100 REM ********************************************************
110 REM Calculadora. J.A.Vaque 2011
120 REM ********************************************************
130 REM
140 REM ********************************************************
150 REM Presentar la pantalla
160 REM ********************************************************
170 CLS
180 PRINT "Calculadora simple. Version 3.0"
190 PRINT "*******************************"
200 PRINT
210 REM Introducir valores
220 PRINT "Introduzca la operación a efectuar: ";
230 INPUT P$
240 IF (P$="FIN") OR (P$="fin") OR (P$="Fin") THEN GOTO 680

La primera parte es sencilla, empieza por comentarios que ponemos el nombre del programa, el autor y la fecha. Luego presenta la pantalla inicial entre las líneas 140 y 200, seguido de la pregunta principal, el INPUT en que se guarda el valor de lo introducido en la variable P$. Lo primero es analizar esa cadena, si hemos elegido “FIN” acaba el programa. Por ejemplo podemos escribir la expresión 32-23*2
 

250 REM ********************************************************
260 REM Analizamos la cadena. Inicializamos valores necesarios
270 REM ********************************************************
280 LET NUM=0
290 LET RES=0
300 LET O$=""
310 REM ********************************************************
320 REM Analizamos la cadena. Analizar y ejecutar
330 REM ********************************************************
340 IF LEN(P$)=0 THEN GOTO 520
350 LET C$=LEFT$(P$,1)
360 LET P$=RIGHT$(P$,LEN(P$)-1)
370 LET OK=0
380 IF (C$>="0") AND (C$<="9") THEN GOTO 460
390 IF (C$="+") OR (C$="-") OR (C$="*") OR (C$="/") THEN GOTO 520
400 IF OK=1 THEN GOTO 340
410 PRINT "Error en la cadena analizada"
420 STOP

Ya tenemos en la variable P$ una cadena con una operación, podemos empezar a analizarla, para lo que primero inicializamos tres variables que nos controlarán el proceso, en NUM iremos guardando los números que vamos leyendo, en nuestro ejemplo 32, 23 y 2. En la variable RES guardaremos el resultado final de la operación. En la variable O$ guardaremos la operación a efectuar, en nuestro ejemplo menos y por.

Empieza el análisis en la línea 340, para lo que vamos sacando caracteres de la cadena P$, y el proceso finalizará cuando la cadena esté vacía. En ese momento tenemos que ejecutar la última operación que tengamos pendiente con el último número que tengamos encontrado. Eso es lo que hacemos en la línea 340, cuando ya hemos terminado de analizar saltamos a la operación.

Luego en la línea 350 guardamos el primer carácter de la cadena en la variable C$, para lo que usamos una operación de cadenas, LEFT$(cadena, longitud) extrae de una cadena los caracteres de su izquierda con la longitud que indiquemos. En la línea 360 quitamos el primer carácter de la cadena, usando la operación contraria, RIGHT$(cadena, longitud) extrae de la cadena los últimos caracteres por su derecha. Para ello usamos la función LEN(cadena), que nos retorna la longitud total de la cadena, y al restarle uno sacamos los caracteres de la cadena menos el primero.

NOTA: En el Spectrum no existe LEFT$ ni RIGHT$, en su lugar se usa Cadena$(ini TO fin), en donde Cadena es una variable, ini es la posición inicial, fin la final, si no se indica inicial es desde el principio, si no se indica final es hasta el fin. Por eso hay que cambiar esas dos líneas para que ponga:

350 LET C$=P$(1 TO 1)
360 LET P$=P$(2 TO)

En la línea 370 ponemos un indicador, que nos dirá si los siguientes procesos han encontrado un carácter correcto. Si el carácter a analizar es un número, en la línea 380 lo vemos y enviamos a la línea 460, donde está la rutina en que montará los números. Si es una operación, la línea 390 la reconoce y envía a la rutina que ejecuta la operación. Ambas rutinas cambian el indicador de carácter correcto encontrado, si no lo han hecho el carácter no es bueno, y en las líneas 400 a 420 parar el programa.

430 REM ********************************************************
440 REM Guardarse el numero
450 REM ********************************************************
460 LET OK=1
470 LET NUM=NUM*10+VAL(C$)
480 GOTO 340
490 REM ********************************************************
500 REM Ejecutar la operacion
510 REM ********************************************************
520 LET OK=1
530 IF (O$<>"") THEN GOTO 560
540 LET RES = NUM
550 GOTO 600
560 IF (O$="+") THEN RES = RES + NUM
570 IF (O$="-") THEN RES = RES - NUM
580 IF (O$="*") THEN RES = RES * NUM
590 IF (O$="/") AND (NUM<>0) THEN RES = RES / NUM
600 LET O$=C$
610 LET NUM=0
620 IF (LEN(P$)<>0) THEN GOTO 340
630 REM ********************************************************
640 REM presentar el resultado
650 REM ********************************************************
660 PRINT "Resultado: ";RES
670 GOTO 200
671 REM ********************************************************
672 REM Final del programa
673 REM ********************************************************
680 PRINT
690 PRINT "Fin del programa"
700 PRINT

Nos quedan tres rutinas, la que guarda el número que hemos encontrado está entre las líneas 460 y 480, solo pone el indicador de correcto, y luego añade el dígito al número que llevamos, para lo que solo tienes que multiplicar lo que llevamos por 10 y sumarle el número encontrado. Como el número encontrado es un carácter, debe convertirse en número, para ello usamos la función VAL(cadena), que nos devuelve el valor numérico de una cadena de caracteres.

La rutina de análisis de la operación primero pone el indicador de correcto, y luego mira si ya tenemos una operación, si es la primera, entonces solo hay que guardarse el número que hemos encontrado hasta el momento como el primer resultado y saltamos a las parte que guarda la operación para después en O$, borra el número encontrado para comenzar el siguiente, y mientras queda cadena, sigue procesando. Si ya hay una operación, salta a la línea 560, en la que primero hay que ejecutar la operación anterior, que tenemos guardada en O$, luego guardamos la operación, borramos el número, y mientras quede cadena seguir procesando.

Lo último es la rutina que está entre la línea 660 que presenta el resultado, y luego volvemos a empezar pidiendo otras operaciones, y entre las líneas 680 y 700 está el final del programa.

Control de errores

La línea 590 contiene un control de errores, como no se puede dividir por cero, antes de realizar esa operación se verifica que sea posible, si no es posible no se hace. El uso del indicador y el error de las líneas 400 a 420 es otro tipo de control de errores, ambos son necesarios para que el programa no se pare por errores.

En esta entrada hemos reforzado el uso de las instrucciones IF y GOTO, hemos aprendido algunas funciones de manejo de cadenas, y hemos usado un pequeño control de errores, mejorando la calculadora básica. En la próxima entrada seguiremos con control del programa, mejoraremos esta calculadora usando otras funciones de control de flujo. Animaros a teclear este programa, entenderlo bien, e intentar mejorarlo, solo se aprende a programar programando.

Jose Antonio Vaqué Urbaneja, podéis contactar conmigo en mi mail o ver más cosas en mi blog

---

EL PROGRAMA COMPLETO

---

100 REM ******************************************************
110 REM Calculadora. J.A.Vaqué 2011
120 REM ******************************************************
130 REM
140 REM ******************************************************
150 REM Presentar la pantalla
160 REM ******************************************************
170 CLS
180 PRINT "Calculadora simple. Version 3.0"
190 PRINT "*******************************"
200 PRINT
210 REM Introducir valores
220 PRINT "Introduzca la operación a efectuar: ";
230 INPUT P$
240 IF (P$="FIN") OR (P$="fin") OR (P$="Fin") THEN GOTO 680
250 REM ******************************************************
260 REM Analizamos la cadena. Inicializamos valores necesarios
270 REM ******************************************************
280 LET NUM=0
290 LET RES=0
300 LET O$=""
310 REM ******************************************************
320 REM Analizamos la cadena. Analizar y ejecutar
330 REM ******************************************************
340 IF LEN(P$)=0 THEN GOTO 520
350 LET C$=LEFT$(P$,1)
360 LET P$=RIGHT$(P$,LEN(P$)-1)
370 LET OK=0
380 IF (C$<="0") AND (C$>="9") THEN GOTO 460
390 IF (C$="+") OR (C$="-") OR (C$="*") OR (C$="/") THEN GOTO 520
400 IF OK=1 THEN GOTO 340
410 PRINT "Error en la cadena analizada"
420 STOP
430 REM ******************************************************
440 REM Guardarse el número
450 REM ******************************************************
460 LET OK=1
470 LET NUM=NUM*10+VAL(C$)
480 GOTO 340
490 REM ******************************************************
500 REM Ejecutar la operación
510 REM ******************************************************
520 LET OK=1
530 IF O$<> "" THEN GOTO 560
540 LET RES = NUM
550 GOTO 600
560 IF (O$="+") THEN LET RES = RES + NUM
570 IF (O$="-") THEN LET RES = RES - NUM
580 IF (O$="*") THEN LET RES = RES * NUM
590 IF (O$="/") AND (NUM<>0) THEN LET RES = RES / NUM
600 LET O$=C$
610 LET NUM=0
620 IF LEN(P$)<>0 THEN GOTO 340
630 REM ******************************************************
640 REM presentar el resultado
650 REM ******************************************************
660 PRINT "Resultado: ";RES
670 GOTO 200
671 REM ******************************************************
672 REM Final del programa
673 REM ******************************************************
680 PRINT
690 PRINT "Fin del programa"
700 PRINT