CONTENIDOS TEMATICOS.http://jm00092.freehostia.com/cqb/indetal.htm

0.0 Introduccin ....................................................................................................................... 1 TEMA 1.1 PRIMEROS PASOS ............................................................................................... 3 1.1.1 PRIMER PROGRAMA EN QBASIC .......................................................................... 3 1.1.2 ENTENDIENDO LO QUE HEMOS HECHO ............................................................. 4 1.1.3 ESTRUCTURA BSICA? ........................................................................................ 4 1.1.4 ESCRIBIR COMENTARIOS ...................................................................................... 5 TEMA 1.2 VARIABLES ......................................................................................................... 6 1.2.1 - INTRODUCCIN A LAS VARIABLES .................................................................. 6 1.2.2 - TIPOS DE DATOS ................................................................................................... 7 1.2.3 - NOMBRES DE VARIABLES ................................................................................... 8 1.2.4 - DECLARACIN DE VARIABLES .......................................................................... 9 1.2.5 - CUIDADO! PELIGRO EN QBASIC! ..................................................................... 10 #T_1_3TEMA 1.3 CONSTANTES .........................................................................................11 1.3.1 - INTRODUCCIN A LAS CONSTANTES ............................................................. 11 1.3.2 - DEFINICIN DE CONSTANTES .......................................................................... 12 1.3.3 - RECOMENDACIN DE USAR CONSTANTES ................................................... 12 TEMA 1.4 ENTRADA Y SALIDA BSICA ..........................................................................13 1.4.1 - INTRODUCCIN A E/S ........................................................................................ 13 1.4.2 - ENTRADA DE DATOS. LEER DESDE EL TECLADO......................................... 13 1.4.3 - CONTROL DE SABOTAJES ................................................................................. 14 1.4.4 - SALIDA. ESCRIBIR EN PANTALLA ................................................................... 16 TEMA 1.5 OPERADORES Y EXPRESIONES.......................................................................18 1.5.1 - Introduccin a los operadores .................................................................................. 19 1.5.2 - Operador de asignacin ........................................................................................... 19 1.5.3 - Contadores y acumuladores ..................................................................................... 20 1.5.4 - Operadores aritmticos ............................................................................................ 20 1.5.5 - Operadores relacionales o de comparacin ............................................................... 21 1.5.6 - Operadores lgicos .................................................................................................. 22 TEMA 1.6 FUNCIONES INCLUIDAS EN EL LENGUAJE ...................................................24 TEMA 1.7 ESTRUCTURAS CONDICIONALES IF ..............................................................27 1.7.1 - INTRODUCCIN A LOS BLOQUES DE CONTROL ........................................... 27 1.7.3 - SANGRA............................................................................................................... 28 1.7.4 - ANIDACIN .......................................................................................................... 28 1.7.5 - INSTRUCCIN IF SIMPLIFICADA ...................................................................... 29 1.7.6 - ALTERNATIVA DOBLE. INSTRUCCIN IF-THEN-ELSE ................................. 29 1.7.7 - ALTERNATIVA MLTIPLE. INSTRUCCIN ELSEIF ........................................ 31

TEMA 1.8 ESTRUCTURA DE SELECCIN SELECT ..........................................................34 TEMA 1.9 ESTRUCTURA DE REPETICIN FOR...NEXT .................................................37 1.9.1 - Introduccin a estructuras de control repetitivas ....................................................... 37 1.9.2 - Cmo detener un programa ...................................................................................... 37 1.9.3 - Instruccin FOR...NEXT ......................................................................................... 38 TEMA 1.10 ESTRUCTURA DE REPETICIN WHILE...WEND ..........................................42 Tema 1.11 ESTRUCTURA DE REPETICIN DO...LOOP ....................................................44 1.11.1 - ESTRUCTURA DO...LOOP ................................................................................. 44 1.11.2 - DEPURACIN DE DATOS DE ENTRADA ........................................................ 45 TEMA 1.12 ARRAYS ............................................................................................................46 1.12.1 - INTRODUCCIN A LOS ARRAYS .................................................................... 46 1.12.2 - VECTORES .......................................................................................................... 47 1.12.3 - MATRICES .......................................................................................................... 51 1.12.4 - POLIEDROS ......................................................................................................... 53 1.12.5 - AHORRAR ESPACIO EN LOS ARRAYS DE CADENAS .................................. 53 1.12.6 - MATRICES ORLADAS ....................................................................................... 54 1.12.7 - FORMACIONES DINMICAS ............................................................................ 55 TEMA 1.13 PROGRAMACIN MODULAR.........................................................................57 1.13.1 - INTRODUCCIN A LA PROGRAMACIN MODULAR ................................... 57 1.13.2 - LA PROGRAMACIN MODULAR EN QBASIC ............................................... 58 1.13.3 - LLAMADA A PROCEDIMIENTOS Y FUNCIONES........................................... 58 1.13.4 - DEFINICIN DE PROCEDIMIENTOS................................................................ 60 1.13.5 - VARIABLES LOCALES ...................................................................................... 61 1.13.6 - VARIABLES GLOBALES ................................................................................... 62 1.13.7 - PASO DE PARMETROS ................................................................................... 63 1.13.8 - DEFINICN DE FUNCIONES ............................................................................. 66 1.13.9 - RECUSIVIDAD .................................................................................................... 68 1.13.10 - DIFERENCIA ENTRE PROCEDIMIENTOS Y FUNCIONES............................ 71 1.13.11 - PROTOTIPOS..................................................................................................... 72 TEMA 1.14 TIPOS DE DATOS DEFINIDOS POR EL USUARIO ........................................73 1.14.1 - DEFINICIN DE NUEVOS TIPOS DE DATOS .................................................. 73 1.14.2 - UNA APROXIMACIN A LA PROGRAMACIN ORIENTADA A OBJETOS . 77 TEMA 1.15 FICHEROS SECUENCIALES ............................................................................78 1.15.1 - INTRODUCCIN AL USO DE FICHEROS......................................................... 78 1.15.2 - INTRODUCCIN A LOS FICHEROS SECUENCIALES .................................... 79 1.15.3 - ESCRIBIR INFORMACIN EN FICHEROS SECUENCIALES .......................... 80 1.15.4 - LEER INFORMACIN DE FICHEROS SECUENCIALES .................................. 82 1.15.5 - ANEXAR INFORMACIN A FICHEROS SECUENCIALES .............................. 84 TEMA 1.16 FICHEROS DE ACCESO DIRECTO O ALEATORIO .......................................85

1.16.1 - INTRODUCCIN A LOS FICHEROS DIRECTOS .............................................. 85 1.16.2 - LECTURA Y ESCRITURA EN FICHEROS DIRECTOS ..................................... 86 1.16.3 MANTENIMIENTO DE FICHEROS DIRECTOS................................................ 89 1.16.3.1 INTRODUCCIN AL MANTENIMIENTO DE FICHEROS ............................ 89 1.16.3.2 - ALTAS. AADIR REGISTROS ........................................................................ 89 1.16.3.3 - CONSULTAS. BSQUEDA SECUENCIAL DE REGISTROS ......................... 90 1.16.3.4 - MODIFICACIONES DE REGISTROS .............................................................. 91 1.16.3.5 - BAJAS. BORRAR REGISTROS ........................................................................ 92 1.16.3.6 - COMPACTACIN DE FICHEROS DIRECTOS ............................................... 93 1.16.3.7 - ELABORACIN DE LISTADOS DE DATOS .................................................. 95 1.16.4 - BREVE IDEA SOBRE BASES DE DATOS ......................................................... 99 1.16.5 - OTRAS INSTRUCCIONES RELACIONADAS CON FICHEROS ......................100 TEMA 1.17 CONTROL DE ERRORES................................................................................103 1.17.1 - INSTRUCCIN GOTO. LA MS CONOCIDA Y ODIADA DE BASIC ............103 1.17.2 - INTRODUCCIN A LOS ERRORES..................................................................104 1.17.3 - CONTROL DE ERRORES...................................................................................106 TEMA 1.18 LLAMADA A PROGRAMAS EXTERNOS ....................................................109 TEMA 2.1 DETECCIN DE TECLAS PULSADAS. LA FUNCIN INKEY$ ...................110 2.1.1 - USO DE LA FUNCIN INKEY$ ..........................................................................111 2.1.2 - RECONOCIMIENTO DE TECLAS ESPECIALES................................................112 2.1.3 - HACER PAUSAS EN LOS PROGRAMAS ...........................................................114 TEMA 2.2 NMEROS ALEATORIOS Y CONTROL DE TIEMPO ...................................115 2.2.1 - MMEROS ALEATORIOS. FUNCIN RND.......................................................115 2.2.2 - CONTROL DE TIEMPO .......................................................................................118 TEMA 2.3 MS SOBRE LAS CADENAS DE CARACTERES ...........................................120 2.3.1 - ACERCA DE LAS CADENAS DE CARACTERES ..............................................120 2.3.2 - LA FUNCIN E INSTRUCCIN MID$ ...............................................................121 2.3.3 - OTRAS FUNCIONES DE MANEJO DE CADENAS ............................................124 TEMA 2.4 MANEJO DE LA PANTALLA EN MODO TEXTO ...........................................126 2.4.1 - INTRODUCCIN A LOS INTERFACES DE TEXTO ..........................................127 2.4.2 - POSICIONAR EL CURSOR EN LA PANTALLA.................................................127 2.4.3 - TEXTO EN COLORES..........................................................................................130 2.4.4 - REDEFINIR COLORES ........................................................................................132 2.4.5 - CARACTERES SEMIGRFICOS .........................................................................133 2.4.6 - CARACTERES ESPECIALES DE RELLENO ......................................................137 2.4.7 - CARACTERES NO IMPRIMIBLES ......................................................................139 2.4.8 - ESMILIS y ASCII-ART ......................................................................................140 TEMA 2.5 GRFICOS .........................................................................................................143 2.5.1 - INTRODUCCIN A LOS INTERFACES GRFICOS ..........................................143

2.5.2 - LOS MODOS DE PANTALLA EN QBASIC.........................................................143 2.5.3 - RENDIMIENTO EN MODO GRFICO ................................................................147 TEMA 2.6 TRAZADO DE FIGURAS GRFICAS ..............................................................147 2.6.1 - EL CURSOR GRFICO ........................................................................................148 2.6.2 - PUNTOS. INSTRUCCIN PSET ..........................................................................148 2.6.3 - LNEAS Y RECTNGULOS. INSTRUCCIN LINE ...........................................149 2.6.4 - CRCULOS Y VALOS. INSTRUCCIN CIRCLE .............................................151 2.6.5 - RELLENAR REAS. INSTRUCCIN PAINT .....................................................152 2.6.6 - DIBUJAR FIGURAS COMPLEJAS. INSTRUCCIN DRAW ..............................154 TEMA 2.7 OTRAS OPERACIONES CON GRFICOS .......................................................157 2.7.1 - DEFINIR MARCOS DE VISUALIZACIN. INSTRUCCIN VIEW ...................157 2.7.2 - SISTEMA DE COORDENADAS PERSONALIZADO ..........................................158 2.7.3 - COPIAR Y PEGAR. INSTRUCCIONES GET Y PUT ...........................................159 2.7.4 - VER EL COLOR DE UN PIXEL. INSTRUCCIN POINT ...................................162 2.7.5 - ESCRIBIR TEXTO EN MODO GRFICO............................................................166 TEMA 2.8 IMPRESIN .....................................................................................................167 TEMA 2.9 EFECTOS DE SONIDO Y MSICA .................................................................170 TEMA 3.1 REFERENCIA RPIDA DEL LENGUAJE DE QBASIC .................................171 TEMA 3.2 CDIGOS DE CARACTERES ASCII ................................................................174 TEMA 3.3 USO DE QBASIC CON EL EMULADOR DOSBOX ........................................175 3.3.1 - Introduccin a los emuladores y a DOSBox ............................................................175 3.3.2 - Instalacin del emulador DOSBox ..........................................................................177 3.3.3 - Instalacin del entorno grfico D-Fend ...................................................................178 3.3.4 - Configuracin del perfil de QBasic .........................................................................179 3.3.5 - Uso de QBasic en el emulador ................................................................................182 3.3.6 - Aprovechando el emulador .....................................................................................183

1

0.0 Introduccin

Los ordenadores son mquinas electrnicas capaces de hacer clculos a gran velocidad y con gran precisin. Para resolver un problema usando una calculadora tenemos que tocar las teclas necesarias y anotar resultados intermedios hasta llegar al resultado final. Para volver a resolver el mismo problema, ya sea con los mismos valores de entrada o con otros, tendremos que volver a tocar todas las teclas de antes y volver a anotar resultados intermedios cuando haga falta, teniendo que entender en todo momento todos los pasos necesarios para dar con la solucin del problema. Esta serie de pasos necesarios para resolver un problema es lo que se conoce con el nombre de Algoritmo. En un ordenador ms avanzado que una calculadora, como es el caso de un PC, podemos introducir una vez nada ms los pasos necesarios para resolver el problema, el algoritmo, y en sucesivas ocasiones que haya que hacer el clculo ser suficiente con introducir los datos de entrada para que el ordenador resuelva el problema siguiendo las instrucciones del programa y nos devuelva como datos de salida la solucin al problema. El usuario del programa no necesita conocer todos los pasos intermedios que han sido necesarios para encontrarla. El ordenador almacena todas las instrucciones y datos en memoria. Como la memoria del ordenador es un dispositivo electrnico digital, solo es capaz de trabajar con nmeros y hacer operaciones muy simples como sumar, comparar si dos nmeros son iguales o copiar

2

datos a otras partes de la memoria o a los registros de datos del microprocesador. Un algoritmo o programa formado por estas instrucciones tan simples sera terriblemente largo y complicado, ya que cualquier proceso informtico como dibujar una letra en la pantalla o calcular una raz cuadrada necesitara muchas de estas operaciones bsicas y por lo tanto construir un programa directamente usando estas instrucciones sera bastante complicado. Para solucionar este inconveniente existen los intrpretes y los compiladores que son programas capaces de entender instrucciones ms o menos fciles y claras para nosotros y convertirlas en secuencias de instrucciones bsicas en cdigo mquina que son las nicas que entiende el ordenador. Para dar las instrucciones a los intrpretes o compiladores no podemos hacerlo de cualquier manera, sino que tenemos que seguir una serie de normas de sintaxis y usar determinadas palabras y smbolos. Esto es lo que se conoce como lenguaje de programacin. Basic es un lenguaje de programacin diseado en la dcada de 1960 en los Estados Unidos originalmente para grandes ordenadores, pero que despus se ha utilizado principalmente como medio de aprendizaje de la programacin, ms que para el desarrollo de aplicaciones comerciales. Las siglas B.A.S.I.C significan "Beginners all-purpose symbolic instruction code", es decir, lenguaje de programacin simblico multipropsito para principiantes. Hay muchas versiones, desde las primitivas que utilizaban nmeros de lneas hasta las ms modernas usadas en Microsoft Visual Basic que incluyen programacin orientada a objetos para entornos Windows. QBasic es un Intrprete del lenguaje Basic que se incluye con los sistemas operativos MS-DOS a partir de las versiones 5.5 sustituyendo a otros ms antiguos como GW-Basic. Se compone del editor de cdigo, del intrprete de Basic y de un depurador sencillo todo integrado en el entorno de programacin QBasic. La versin de Basic que soporta es bastante avanzada y no necesita que escribamos nmeros de lneas, al mismo tiempo que cuenta con las instrucciones de control necesarias como para que podamos programar respetando los principios de la Programacin Estructurada. El lenguaje de QBasic se ha quedado obsoleto por ser para el sistema MS-DOS y no para Windows, adems de que al ser un intrprete no nos permite distribuir las aplicaciones que hagamos de forma independiente de QBasic. Aunque no nos vale para escribir programas comerciales, nos va a servir para aprender a programar de la forma ms sencilla posible y sin complicarnos teniendo que escribir cosas que no entendemos todava. Adems el entorno est en castellano y es muy estable, por lo que nuestros programas nunca van a bloquear el ordenador. QBasic funciona perfectamente en Windows. Una vez terminado el curso todo lo aprendido lo podremos ampliar para empezar con Visual Basic, o bien nos servir para empezar a

3

programar en Pascal o en C, lenguajes mucho ms completos que Basic, pero algo ms complicados. Los fundamentos de programacin que aprendamos durante el curso van a ser los mismos en la mayora de lenguajes.

TEMA 1.1 PRIMEROS PASOSy y y y

1.1.1 1.1.2 1.1.3 1.1.4

-

Primer programa en QBasic Entender lo que hemos hecho Estructura bsica Escribir comentarios

1.1.1 PRIMER PROGRAMA EN QBASIC Es tradicional en programacin que al empezar con un nuevo lenguaje para empezar a entenderlo se escriba un programa que borre la pantalla y escriba las palabras "Hola mundo", all vamos paso por paso. Desde MS-DOS entraramos en el directorio donde tenemos QBasic y a continuacin cargamos el programa. CD DOS[Enter] QBasic[Enter] O lo ms comn en estos tiempos, desde Windows buscamos el programa QBasic.exe o un acceso directo que apunte a l y hacemos doble clic sobre su icono. (Muchas veces encontraremos los accesos directos a QBasic con el nombre de Microsoft Quick Basic) En el editor podemos empezar a escribir todo el cdigo de nuestro programa. Esto es como un procesador de textos, solo que en vez de escribir lo que queramos slo se puede escribir en lenguaje Basic. Si escribimos otra cosa, cuando pasemos a la siguiente lnea pulsando "Enter" el programa se dar cuanta de que algo no va bien y nos sacar un mensaje de error. Vamos a escribir nuestro programa. cls print "Hola Mundo" Ya est! Ahora que ya nos hemos hartado de escribir todo el cdigo del programa vamos a probar a ver si funciona. Pulsamos la tecla F5 La pantalla se pondr toda negra y en la esquina superior izquierda aparecer de color gris el rtulo "Hola Mundo". Ya est. Nuestro programa hace lo que queramos. Abajo aparecen unas letras que dicen "Presione cualquier tecla y contine". Este rtulo lo escribe automticamente QBasic para indicarnos que nuestro programa ha terminado y que cuando pulsemos cualquier tecla volveremos al editor de cdigo. Pulsa cualquier tecla y ya ves otra vez la pantalla azul del editor con las instrucciones del programa.

4

Para no tener que hartarnos otro da de escribir nuestro pedazo de programa vamos a grabarlo en el sistema de archivos de nuestro ordenador. Abrimos el men "Archivo" y seleccionamos "Guardar". Aparece un cuadro de dilogo donde se nos pide el nombre del archivo. El manejo del cuadro de dilogo es muy sencillo, pero hay que tener en cuenta que como QBasic funciona en MS-DOS los nombres de los archivos no pueden tener ms de 8 caracteres ni pueden incluir espacios en blanco. Tampoco es conveniente usar caracteres especiales ni letras acentuadas ni . Los programas que hagamos en QBasic se guardan en un nico fichero de texto ASCII con extensin ".BAS" que contiene el cdigo fuente del programa, es decir, las instrucciones en lenguaje Basic que hemos escrito para que el programa funcione. 1.1.2 ENTENDIENDO LO QUE HEMOS HECHO Ahora vamos a ver recordar el Cdigo de nuestro programa. CLS PRINT "Hola Mundo" Vemos que hay dos instrucciones: CLS borra la pantalla (Igual que en MS-DOS) y PRINT "Hola Mundo" escribe en la pantalla "Hola Mundo". Las dos instrucciones se han ejecutado una detrs de otra, por eso podemos decir que un programa es un listado de instrucciones que se ejecutan de forma secuencial una detrs de otra desde la primera hasta la ltima. Al escribir el programa habrs observado que seguramente escribiste cls y al pasar de lnea se puso en maysculas como CLS. Y despus con print pas lo mismo, pero "Hola Mundo" se ha quedado como lo escribiste. Esto es porque CLS y PRINT son instrucciones del lenguaje Basic que se ponen en maysculas automticamente para dar mayor legibilidad al programa. "Hola Mundo" va entre comillas porque es un Literal o una expresin de cadena y se va a quedar siempre como t lo has escrito. 1.1.3 ESTRUCTURA BSICA? Veamos en un momento como sera un programa en lenguaje PASCAL que haga lo mismo que el nuestro: Program Hola; uses crt; begin clrscr; writeln("Hola Mundo"); end. Y lo mismo en lenguaje C: #include < stdio.h > int main(void) { clrscr(); cprintf("Hola Mundo");

5

return(0); } Podemos ver que en los dos estn las instrucciones para borrar la pantalla (clrscr) y la de escribir (writeln en PASCAL y cprintf en C), pero Por que llevan punto y coma al final? y Qu son esos smbolos y esas otras palabras tan raras?... En otros lenguajes de programacin hace falta escribir un "esqueleto bsico" donde montar las instrucciones, en QBasic no. Nos limitamos a escribir lo que queremos que haga el programa y ya est. Estas estructuras bsicas son necesarias en los otros lenguajes ms avanzados, pero en QBasic como slo vamos a aprender as lo tenemos ms fcil sin tener que escribir cosas que todava no entendemos. 1.1.4 ESCRIBIR COMENTARIOS Los programas que veamos al principio de este curso van a ser muy sencillos y se explican por s solos, pero una vez vayamos aprendiendo a programar y hagamos programas cada vez ms largos nos encontraremos con el problema de que pasado un tiempo tengamos que revisar el programa y no nos acordemos de lo que hacen algunas instrucciones, o que nuestro programa lo vea otra persona y no sepa por dnde cogerlo. Para solucionar este problema los lenguajes de programacin nos dan la posibilidad de escribir comentarios dentro del listado del programa para explicar su funcionamiento. Lo que pongamos en los comentarios no altera para nada el funcionamiento del programa. En QBasic para escribir un comentario ponemos un apstrofo ('). La tecla del apstrofo est en el bloque alfanumrico del teclado en la fila de arriba, a la derecha del cero. Todo lo que escribamos a continuacin del apstrofo ya no ser tenido en cuenta a la hora de ejecutar el programa. Veamos nuestro ejemplo con comentarios: ' PROGRAMA HOLA MUNDO ' Escribe en la pantalla "Hola Mundo" ' ' Este ejemplo forma parte del curso ' de introduccin a la programacin ' CLS 'Borra la pantalla PRINT "Hola Mundo" 'Escribe "Hola mundo" Aqu hemos puesto una cabecera describiendo el programa y a continuacin a la derecha de algunas instrucciones, en este caso de todas, hemos explicado para que sirven. En los programas ya terminados es conveniente poner la cabecera siempre y explicar las instrucciones ms complicadas. El formato de la cabecera vendr especificado en el proyecto, por ejemplo que contenga el nombre del programa, una descripcin corta, el autor y la fecha. En nuestros programas no es necesario ser tan estrictos.

6

Otra utilidad que se da a los comentarios en los entornos de programacin es la de conseguir que un trozo de programa no se ejecute. Por ejemplo podemos poner como comentario la parte de un programa dnde se nos pide la clave de acceso y que ya hemos comprobado que funciona, para que no nos la pida cada vez que entremos a comprobar otra cosa. Al final nos tendremos que acordar de quitar estos comentarios para que todo funcione bien.

TEMA 1.2 VARIABLESy y y y y

1.2.1 1.2.2 1.2.3 1.2.4 1.2.5

-

Introduccin a las variables Tipos de datos Nombres de variables Declaracin en variables Cuidado, peligro en QBasic!

1.2.1 - INTRODUCCIN A LAS VARIABLES Nuestro programa anterior funciona muy bien, pero siempre que lo ejecutemos va a suceder lo mismo, borrar la pantalla y escribir un rtulo que diga "Hola Mundo". Vamos a escribir un programa un poco ms complicado que nos pregunte nuestro nombre y nos salude. El resultado (lo que se ve en pantalla al ejecutarlo) podra ser el siguiente: Cmo te llamas? juanma Hola juanma El programa borrar la pantalla (Esto lo vamos a hacer siempre para no confundirlo con lo anterior que pueda haber), nos preguntar por nuestro nombre, nos dejar escribirlo con el teclado y cuando lo hagamos lo guardar en "algn sitio", despus escribir "Hola " seguido de nuestro nombre que lo habr sacado del "sitio" donde lo guard antes. Vamos a ver cmo ser el cdigo: CLS INPUT "Cmo te llamas? ", nombre$ PRINT "hola "; nombre$ Ahora tenemos una instruccin nueva, INPUT, que lleva dos parmetros separados por una coma. Esta instruccin lo que hace es dejar al usuario del programa que escriba algo con el teclado y cuando pulse la tecla Enter lo guarda en memoria. La primera parte "Cmo te llamas?" la escribe en pantalla tal como est para que el usuario sepa lo que se le pregunta. La segunda parte es una Variable, es decir el nombre que le hemos puesta a un "trozo" de la memoria del ordenador dnde vamos a guardar lo que ha escrito el usuario y que le hemos llamado nombre$ para despus poder localizarlo. La siguiente instruccin, PRINT, es la misma que en el anterior programa. Lo que hace es escribir lo que lleva detrs. En esta ocasin va a escribir dos cosas, primero "Hola " con su espacio detrs tal como aparece dentro de las comillas, y a continuacin todo seguido

7

escribir el valor que haya guardado en la variable nombre$. No escribir Hola nombre$ porque nombre$ no est entre comillas. Esto de las variables es una de las cosas ms importantes de los lenguajes de programacin. Los programas van a manejar datos que estarn grabados en la memoria del ordenador. Si no existieran las variables tendramos que saber en que posicin exacta los guardamos y despus para recuperarlos habra que escribir los nmeros de las direcciones de memoria y saber exactamente cuanto largo son los datos. Esto es muy complicado (Esto es lo que se hace en los Lenguajes Ensambladores), para hacerlo aqu ms sencillo usaremos los nombres de variables y QBasic se encargar de ver en que lugar fsico de la memoria mete la informacin y despus de saber recuperarla cuando se la pidamos. 1.2.2 - TIPOS DE DATOS Nuestros programas van a poder trabajar con varios tipos de informacin, como son letras, nmeros con o sin decimales, etc. Nuestro programa anterior usaba una variable de texto o de cadena de caracteres para almacenar nuestro nombre, pero en otros casos habr que almacenar nmeros ms o menos grandes, por ejemplo. Veamos ahora los tipos de datos que hay en QBasic.NOMBRE SUFIJO DESCRIPCIN Texto con cualquier carcter Nmeros enteros Nmeros enteros ms grandes Nmeros con decimales Nmeros con ms decimales MNIMO Y MXIMO 0 a 32767 caracteres -32768 a 32767 2.147.483.647 a2.147.483.648 2,8x1045 a 2,8x1045 4,9x10324 a 4,9x10324

STRING

$

INTEGER

%

LONG

&

SINGLE

!

DOUBLE

#

Vamos ahora a ver lo que significa esta tabla. En QBasic las variables van a ser de uno de estos cinco tipos. Si queremos almacenar palabras, nombres, fechas, horas, cdigos postales, nmeros de telfono, DNIs, matrculas, etc. tendremos que usar una variable de tipo Cadena (STRING) cuyo nombre llevar al final el carcter $.

8

Para guardar nmeros tendremos que usar alguno de los otros cuatro tipos de variables. Si nuestros nmeros no van a llevar decimales usaremos una variable de tipo entero (INTEGER) que ocupa poca memoria (2 bytes) y adems el ordenador trabaja con ellas muy rpido. Si los nmeros enteros van a llegar a ser mayores de 32.767 tendremos que utilizar una variable de tipo Entero largo (LONG) en la que "caben" hasta nmeros mayores que dos mil millones. Si vamos a usar nmeros reales (que pueden llevar decimales) tendremos que usar variables de precisin sencilla (SINGLE). Para algn clculo que necesite obtener resultados con muchos decimales usaremos las variables de doble precisin (DOUBLE) que son ms lentas de manejar y ocupan ms memoria que las anteriores. Si intentamos guardar en una variable un valor ms grande (o ms pequeo si es negativo) de lo que permite su tipo de datos, se producir un "Error de Tiempo de Ejecucin" y el programa se parar. 1.2.3 - NOMBRES DE VARIABLES Cada variable llevar un nombre que nosotros decidamos para usarla en nuestro programa. Tenemos que elegir nombres que no sean demasiado largos y que tengan algo que ver con lo que va a contener la variable. Los nombres de variables deben cumplir estas condiciones: y Deben tener entre 1 y 40 caracteres. y Pueden incluir letras y nmeros. y No pueden llevar la ni letras acentuadas. y El primer carcter tiene que ser una letra. Estos nombres de variable son vlidos. y Edad y fechaNacimiento y jugador1 y iva16porCiento y vidasRestantes Estos otros nombres no son vlidosy y y y

2jugadores (No empieza por una letra) ao (Contiene la ) elPatioDeMiCasaEsParticularYCuandoLlueveSeMoja (Muy Largo) puntuacin (Lleva acento)

Hay que tener en cuenta que QBasic no distingue de maysculas y minsculas, por lo tanto una variable que se llame nivel ser la misma que Nivel, NIVEL o niVEL. De hecho cuando cambiemos las maysculas y minsculas de una variable se cambiarn todas las que ya haya escritas en el resto del programa, es decir, si hemos escrito en un sitio puntos y despus escribimos PuntoS en otro sitio, la anterior tambin se cambiar a PuntoS.

9

Por convenio los nombres de las variables se escriben todo en minsculas para diferenciarlos visualmente de las Palabras Claves que se van poniendo en maysculas automticamente. Si una variable lleva dos palabras se suele escribir la primera letra de la segunda palabra en maysculas para separar un poco, por ejemplo nombreJugador totalActivo o nuevoRegistro. En las variables que deberan llevar la hay varias formas: Para ao se suele escribir cosas como ano, anno o anyo. De los acentos pasamos. En Visual Basic se pueden usar nombres de variables con y acentos, pero en QBasic no. 1.2.4 - DECLARACIN DE VARIABLES En otros lenguajes de programacin (la mayora) hay que Declarar las variables al principio del programa. Esto significa escribir una instruccin que diga algo as como "Voy a usar una variable que se va a llamar nombre y va a ser de tipo cadena" y as con cada una de las variables que vayamos a usar en el programa. En QBasic NO hace falta declarar las variables. La primera vez que escribimos el nombre de una variable QBasic reserva en memoria el espacio para utilizarla y ya est disponible durante el resto del programa, pero Cmo sabe QBasic del tipo que queremos que sea la variable? En la tabla de tipos de datos haba una columna que pona Sufijo y que para cada tipo de datos tena un smbolo distinto. NOMBRE STRING INTEGER LONG SINGLE DOUBLE SUFIJO $ % & ! #

Para indicar el tipo escribiremos uno de estos sufijos detrs del nombre de la variable, por ejemplo si nombre va a contener texto escribiremos nombre$ (Como hicimos en el ejemplo). A esto se llama declaracin implcita, ya que dentro del nombre va includo el tipo de datos. Ahora Que pasa si escribimos en distintos sitios el mismo nombre de variable con distintos sufijos?, por ejemplo: variable$ = "Esto es un texto" variable% = 2000

10

PRINT variable$ PRINT variable% Lo que ocurrir es que QBasic entiende que son dos variables completamente distintas, cada una de un tipo y nos da como resultado: Esto es un texto 2000 Esto puede producir un Error de Lgica, es decir, el programa funciona perfectamente, pero a lo mejor no hace lo que esperbamos. Para evitar esto hay que poner a las variables nombres ms descriptivos, y si en este caso de verdad queramos dos variables es mejor ponerles nombres distintos para evitar confusiones. Tambin puede pasar que se nos olvide ponerle a una variable el sufijo de tipo, entonces QBasic la tratar como de tipo real de precisin sencilla, que es el tipo predeterminado. Para ver como se cambia el tipo predeterminado mira en la ayuda de QBasic la instruccin DEFINT y similares. En la prctica a partir de ahora vamos a poner el sufijo $ a las variables de cadena y las dems las dejamos sin sufijo para que sean reales que admiten nmeros muy grandes con o sin decimales. Si furamos a hacer programas muy depurados sera conveniente usar los otros tipos de variables cuando fuera necesario para que fueran ms eficientes con el consumo de memoria. Las variables al ser usadas la primera vez antes de asignarles (guardar en ellas) ningn valor contienen un texto de longitud cero si son de cadena o el nmero 0 si son de otro tipo. En otros lenguajes de programacin esto no es as y contienen cualquier valor que hubiera en esa posicin de memoria de otros programas que la hubieran usado antes, por lo que se pueden producir errores. Aqu no. Lo ltimo que queda es saber que el Tiempo de Vida de una variable es desde que se usa por primera vez (desde que se declara o se ejecuta la lnea donde su nombre aparece por primera vez) hasta que el programa termina, despus su valor se pierde. No podemos contar con que tengamos valores en memoria guardados de la vez anterior que ejecutamos el programa. 1.2.5 - CUIDADO! PELIGRO EN QBASIC! No tener que declarar las variables puede parecer una ventaja, pero por el contrario ES UN GRAVE INCONVENIENTE de QBasic. El problema menos importante es que usaremos nuevas variables cada vez que queramos sin acordarnos de las anteriores que a lo mejor ya no volvemos a usar, y por lo tanto nuestros programas van a usar ms memoria de la necesaria. El problema ms grave es que si en un sitio escribimos mal el nombre de una variable (o confundimos el sufijo de tipo) QBasic se creer que

11

estamos usando una nueva variable y nuestro programa seguir funcionando como si nada, pero los clculos no saldrn bien. Veamos el siguiente ejemplo, otra vez el programa saludador con un error de este tipo: cls input "Cmo te llamas? ", nombre$ print "hola "; nomber$ Una vez que lo ejecutemos podra pasar esto: Cmo te llamas? Juanma Hola No ha producido ningn error de Tiempo de Ejecucin (No se ha parado y ha terminado correctamente), pero no nos ha saludado con nuestro nombre!!! Nuestro nombre lo guard en la variable nombre$ cuando lo escribimos, pero al respondernos ha escrito "Hola " y a continuacin el valor de la variable nomber$ que es otra variable nueva distinta y que est vaca. Aqu es muy sencillo de ver lo que pasa, pero en un programa de mil lneas con cuarenta variables puede ser muy complicado incluso saber cual variable es la que hemos escrito mal. Por esto hay que tener ESPECIAL CUIDADO en QBasic al escribir los nombres de las variables. En otros lenguajes las variables estn declaradas al principio y si escribimos alguna mal nos da un error de compilacin de tipo "Identificador desconocido" y en muchos casos hasta nos seala la lnea donde est la variable mal escrita para que la corrijamos. En QBasic la mayora de las veces que el programa funciona bien pero no hace lo que queremos es que hemos escrito mal el nombre de alguna variable. Cuando tenemos nombres de variables largos un truco para ver si estn bien escritos todos es buscar una variable que est bien escrita seguro y poner la ltima letra en maysculas, por ejemplo si tenemos identificador lo cambiaramos por identificadoR que para QBasic sigue siendo lo mismo, pero al hacerlo se cambiarn todas las variables con nombre identificador por identificadoR en todo el programa y si al dar un repaso rpido vemos que alguna acaba con r minscula es que alguna letra est mal escrita y habr que repasarla y corregir el error.

TEMA 1.3 CONSTANTESy y y

1.3.1 - Introduccin a las constantes 1.3.2 - Definicin de constantes 1.3.3 - Recomendacin de usar constantes

1.3.1 - INTRODUCCIN A LAS CONSTANTES Cuando hagamos programas que usen variables nos daremos cuenta de que hay variables cuyo valor realmente no cambia a lo largo de

12

todo el programa. Podemos tratar estas variables de una forma especial para que el ordenador las maneje de forma ms eficiente. Estas variables las definiremos como constantes al principio del programa dndoles un valor, y despus podremos usar este valor dentro del programa cuando nos haga falta, pero no modificarlo.

1.3.2 - DEFINICIN DE CONSTANTES Usaremos la palabra clave CONST seguida del nombre de la constante, el signo igual y el valor que le vamos a dar. Ejemplos: CONST pi = 3.14 CONST iva = 16 CONST ruta = "c:\basic\prg\" Para los nombres valen las mismas reglas que para los nombres de variables, es decir, hasta 40 caracteres sin ni acentos, etc... Tambin se suelen poner todo en minsculas. El tipo de datos lo adivina QBasic a partir del valor que le asignamos, por eso no es necesario poner los sufijos de identificacin de tipo (%, !, &, #, $), pero si usamos muchas constantes sera recomendadle hacerlo para dar ms legibilidad al programa. Al definir constantes numricas podemos hacer referencias a otras constantes definidas anteriormente, por ejemplo: CONST precio = 380 CONST dobleprecio = precio * 2 CONST mitadprecio = precio / 2 Esto no se utiliza mucho, pero puede evitar errores. En el ejemplo si el valor de precio es correcto, seguro que tambin lo son los valores de las otras dos constantes. 1.3.3 - RECOMENDACIN DE USAR CONSTANTES En los programas extensos puede ser recomendables usar constantes para determinados valores que alguna vez en el futuro puede que nos interese cambiar. Imaginemos un programa de contabilidad en el que se calculan precios con IVA del 16 por ciento. Lo ms fcil sera escribir el nmero 16 en cada operacin donde sea necesario y ya est, pero imaginemos que cambian las leyes y el IVA pasa a ser del 18 por ciento. Para seguir usando el programa habra que revisar todas las lneas del listado, con el enorme trabajo que esto puede suponer, y en todos los sitios relacionados con IVA dnde hubiera un 16 poner un 18, pero podran pasar dos cosas: y Que cambiramos un 16 por un 18 en algo que no tuviera nada que ver con el IVA. y Que en algn sitio dejemos el 16 para calcular el IVA. En cualquiera de los dos casos nuestro programa dejara de funcionar correctamente ya que hara los clculos mal.

13

Para evitar este problema basta con definir al principio del programa una constante... CONST iva = 16 ... y dentro del programa usar el nombre de la constante en vez de escribir el nmero 16. Si cambian las leyes del IVA bastar con cambiar el valor de la constante... CONST iva = 18 ... y ya est, el programa seguir funcionado perfectamente todo con el 18 por ciento. En los programas grandes bien estructurados se utilizan constantes para todos los valores que pueden cambiar alguna vez. Por ejemplo en un juego puede que en futuras versiones queramos cambiar la puntuacin mxima o el nmero de vidas disponibles.

TEMA 1.4 ENTRADA Y SALIDA BSICAy y y y

1.4.1 1.4.2 1.4.3 1.4.4

-

Introduccin a E/S Entrada. Leer desde teclado Control de sabotajes Salida. Escribir en pantalla

1.4.1 - INTRODUCCIN A E/S En el tema anterior hemos visto una forma de que nuestro programa se comunique con la memoria del ordenador: usando las variables. Aqu vamos a ver la forma de que nuestro programa se comunique con el usuario. La forma ms sencilla de hacerlo es a travs de la "Consola en Modo Texto", es decir leyendo lo que el usuario escriba con el teclado y dando los resultados a travs de la pantalla en forma de texto (Como en MS-DOS). En otros temas ms adelante veremos cmo dibujar en la pantalla, cmo usar la impresora y cmo leer y escribir informacin en el sistema de archivos. Antes de seguir hay que aclarar que "Leer" significa que el programa lea los datos de entrada que el usuario ha escrito, y "Escribir" significa poner en la pantalla los resultados de el programa para que el usuario los vea. No al revs, las instrucciones son para el ordenador. 1.4.2 - ENTRADA DE DATOS. LEER DESDE EL TECLADO La orden que usaremos en QBasic para leer lo que el usuario escribe en el teclado es INPUT. Ya la hemos usado, pero vamos a verla con ms tranquilidad. Su sintaxis ms comn sera: INPUT "Pregunta al usuario", variable y "Pregunta al usuario" es una cadena de texto entre comillas que aparecer en pantalla para que el usuario la vea y sepa lo que se le est preguntando. No puede ser una variable ni una expresin,

14

solamente una cadena entre comillas. En otros lenguajes de programacin no se da esta posibilidad y hay que escribir un rtulo justo antes usando otra instruccin. y variable es el nombre de la variable dnde se almacenar la informacin que escriba el usuario. Al ejecutar esta instruccin se escribe en la pantalla el texto que hay entre comillas y a la derecha aparece el cursor intermitente para que el usuario escriba. El programa estar parado hasta que el usuario escriba lo que quiera y pulse la tecla "Enter". Entonces se almacena en la variable lo que ha escrito el usuario (El valor anterior que pudiera tener la variable se pierde) y el programa sigue con la siguiente instruccin que haya. El usuario podr desplazarse con las flechas del teclado por el texto que est escribiendo para corregir algn error antes de pulsar "Enter" Para que lo que escriba el usuario no salga justo pegado al texto de la pregunta lo que se suele hacer es escribir un espacio en blanco al final dentro de las comillas. Si escribimos... INPUT "Cmo te llamas?",variable$ El resultado despus de que el usuario termine de escribir sera Cmo te llamas?Juanma Pero si lo ponemos con el espacio al final... INPUT "Cmo te llamas? ",variable$ El resultado es parecido pero se ve mejor Cmo te llamas? Juanma La variable tiene que ser del tipo correcto, si le pedimos al usuario que escriba una palabra, la variable debe de ser de tipo cadena y si no tendr que ser de tipo numrico con o sin decimales. Si solo ponemos la variable, sin pregunta al usuario, aparecer un interrogante. Es decir, si ponemos... INPUT nombre_variable Aparecer en la pantalla ?_ Para que no aparezca indicacin alguna, solo el cursor, hay que poner las comillas vacas, por ejemplo... INPUT "", nombre_variable Esto puede ser til cuando la pregunta que hacemos al usuario incluye algn clculo o expresin de cadena. Como INPUT no permite evaluar expresiones en la pregunta al usuario, esta pregunta habr que mostrarla antes en una instruccin PRINT normal de las que veremos ms adelante con su punto y coma al final, y a continuacin poner el input de esta forma para leer la informacin del usuario. 1.4.3 - CONTROL DE SABOTAJES Con estas instrucciones puede pasar que el usuario escriba cosas no vlidas, ya sea por descuido o para intentar provocar un fallo en el programa. Ms adelante veremos como asegurarnos, por ejemplo de que si le pedimos el da del mes no pueda escribir 450, en este

15

apartado solo vamos a ver lo que hace QBasic en situaciones que en otros lenguajes podran dar un error. Qu ocurre si el usuario pulsa la tecla Enter sin haber escrito nada? Si la variable es de texto se almacenar en ella una cadena de longitud cero, es decir "". Si la variable era de cualquier tipo numrico se almacenar en ella el nmero cero. Qu ocurre si el usuario escribe letras cuando le pedimos un nmero? INPUT "Escribe un nmero: ",variable PRINT variable En otros lenguajes se producira un error. QBasic saca un rtulo que pone "Empezar nuevamente" y nos vuelve a repetir la pregunta, hasta que no escribamos un nmero no seguimos. Escribe un nmero: No quiero Empezar nuevamente Escribe un nmero: Que no! Empezar nuevamente Escribe un nmero: 2 2 Si el usuario escribe un nmero cuando le pedimos letras se guarda el nmero como texto en la variable de tipo cadena, no podr ser usado directamente para hacer operaciones matemticas. Qu ocurre si el usuario escribe un nmero muy grande? INPUT "Escribe un nmero: ",variable% PRINT variable% Si el valor escrito no cabe en la variable aparece un rtulo de "Desbordamiento" y se repite la pregunta hasta que el nmero quepa. Recordemos como ejemplo que en las variables de tipo entero el valor mximo es 32767: Escribe un nmero: 99999999999999999999999999999 Desbordamiento Empezar nuevamente Escribe un nmero: 32769 Desbordamiento Empezar nuevamente Escribe un nmero: 32000 32000 Y si el usuario escribe algo que llega al extremo derecho de la pantalla? Se sigue escribiendo en la siguiente lnea por la izquierda. QBasic no le dejar de escribir ms de 256 caracteres. Qu ocurre si el usuario escribe decimales cuando se le pide un nmero entero? INPUT "Escribe un nmero entero: ",variable% PRINT variable% QBasic redondear el valor al guardarlo en la variable entera, si la parte decimal es menor que 0,5 se quitan los decimales, si es igual o

16

mayor que 0,5 se aumenta una unidad, igual que hacamos para convertir de Pesetas a Euros. Escribe un nmero entero: 4.4 4 Escribe un nmero entero: 4.499 4 Escribe un nmero entero: 4.5 5 Escribe un nmero entero: 4.59 5 Recordemos que en MS-DOS Normalmente se utiliza el punto como separador decimal. Si escribimos una coma QBasic se creer que estamos escribiendo letras y nos repetir la pregunta. Escribe un nmero: 6,2 Empezar nuevamente Escribe un nmero: 6.2 6 1.4.4 - SALIDA. ESCRIBIR EN PANTALLA Como ya hemos dicho, la forma ms bsica de dar al usuario los resultados de nuestro programa es a travs de la pantalla. En temas posteriores se explica cmo conseguir crear las pantallas de los programas para que cada cosa aparezca en un sitio determinado y con distintos colores, recuadros, etc, pero por ahora para aprender a programar nos limitaremos a escribir cosas una debajo de otra como en MS-DOS. Usaremos la pantalla de texto de forma que cuando lleguemos a escribir en la lnea ms baja de la pantalla todo subir hacia arriba y desaparecer lo que hubiera en la primera lnea. Para aclarar la pantalla y no liarnos con lo anterior hemos puesto en todos los ejemplos CLS como primera instruccin para que se borre de la pantalla lo que hubiera de ejecuciones anteriores del programa actual o de otro, y se empiece a escribir en la parte superior. Ahora vamos a ver con ms detalle la instruccin PRINT que es la que usamos parara escribir en la pantalla. Una aclaracin. Si a alguien le parece que PRINT significa imprimir tiene razn, en informtica a escribir en la pantalla del ordenador tambin se le puede llamar imprimir en pantalla. Adems esta orden PRINT tambin se utiliza para imprimir como se ver ms adelante. La sintaxis de la instruccin es: PRINT texto Donde texto puede ser una cadena de caracteres entre comillas, que se escribir tal cual. PRINT "Esto es un texto" o el nombre de una variable. mensaje$ = "Prueba superada" PRINT mensaje$

17

En este caso se escribir el valor de que tenga la variable, en nuestro ejemplo se escribira Prueba Superada. La variable tambin puede ser de tipo numrico... PRINT total% Tambin podemos escribir el resultado de operaciones matemticas... PRINT 2+2 En este caso se escribir 4. Las operaciones matemticas (Expresiones) las veremos con detalle en el tema siguiente. Despus de escribir algo el cursor (invisible) pasa a la lnea de abajo, por ejemplo PRINT "Uno" PRINT "Dos" PRINT "Tres" Escribira... Uno Dos Tres Pero en algn caso nos puede interesar que no sea as y que se escriba lo siguiente a continuacin en la misma lnea. Para hacerlo no tenemos ms que escribir un punto y coma al final de la instruccin sobre la que queremos seguir, por ejemplo: PRINT "Uno"; PRINT "Dos"; PRINT "Tres" PRINT "Cuatro" Escribira... UnoDosTres Cuatro Normalmente en una instruccin PRINT se suelen escribir varias cosas, como vimos en el programa saludador que primero escriba la palabra Hola y despus nuestro nombre que estaba almacenado en la variable nombre$. Para hacer esto basta separar con punto y coma (;) las distintas "cosas" que queremos escribir, por ejemplo: nombrePrograma = "Super Juego" nombreUsuario = "JM" PRINT "Hola "; nombreUsuario; ", bienvenido a "; nombrePrograma Escribira... Hola JM, bienvenido a Super Juego Observa que los espacios entre palabras hay que ponerlos en algn sitio dentro de las comillas, de lo contrario saldra todo junto, incluso alguna vez es necesario hacer... PRINT unaVariable$ ; " "; otraVariable$ ...para que no salga todo junto. Ahora vamos a probar con esto: PRINT 2; 3; 4 Visto la anterior, el resultado tendra que ser... 234 Pero no, es

18

2 3 4 QBasic escribe siempre los nmeros con un espacio delante y otro detrs. Lo que ha escrito exactamente es: Espacio 2 Espacio Espacio 3 Espacio Espacio 4 Espacio, el ltimo espacio no lo vemos pero tambin lo ha escrito. Una consecuencia de esto ser que los nmeros por ahora nunca van a salir justo en la parte izquierda de la pantalla, sino una posicin ms adelante, por ejemplo... PRINT "Prueba" PRINT 25 PRINT 74 PRINT "Fin prueba" Escribira... Prueba 25 74 Fin Prueba Pero de esto no nos tenemos que preocupar. Si intentamos arreglarlo vamos a complicar nuestros programas innecesariamente. Ya habr tiempo de dibujar pantallas en los temas de ampliacin. Una cosa que s podemos hacer ya es usar lo que se llama "Posiciones de tabulacin". Esto es que QBasic divide cada lnea de la pantalla en posiciones que comienzan cada 14 caracteres, la primera en la posicin 1, la segunda en la 14, la tercera en la 28, etc. Y si nosotros separamos las expresiones de la orden PRINT con comas en vez de puntos y comas los textos se escribirn en estas posiciones en vez de justo pegado a la anterior. Vamos con un ejemplo: PRINT "Uno", "Dos", "Tres" PRINT "Cuatro", "Cinco", "Seis" PRINT "Siete", "Ocho", "Nueve" Que escribira en pantalla... Uno Dos Tres Cuatro Cinco Seis siete Ocho Nueve Esto ser muy til en los listados que veremos ms adelante. Por supuesto en una misma instruccin podemos separar unas cosas con comas y otras con puntos y comas, segn haga falta.

TEMA 1.5 OPERADORES Y EXPRESIONESy y y y y y

1.5.1 1.5.2 1.5.3 1.5.4 1.5.5 1.5.6

-

Introduccin a los operadores Operador de asignacin Contadores y acumuladores Operadores aritmticos Operadores relacionales o de comparacin Operadores lgicos

19

1.5.1 - Introduccin a los operadores En este tema vamos a ver como construir las expresiones matemticas y lgicas necesarias para que nuestros programas sea capaces de hacer clculos. Una expresin sera lo equivalente a las frmulas que escribimos en una hoja de clculo (Excel), es decir una sucesin de nmeros, operadores (signos ms, menos, etc.) y nombres de variables, entre otras cosas, colocados en el orden correcto. 1.5.2 - Operador de asignacin Lo primero que vamos a ver en este tema es un operador que nos permita guardar "algo" en una variable. En el programa Saludador para guardar nuestro nombre en la variable nombre$ usbamos directamente la instruccin INPUT que se encargaba de leer los datos del teclado y guardarlos directamente en la variable. Aqu no emplebamos el operador de asignacin, pero despus hemos hecho cosas como: mensaje$ = "Prueba superada" o al declarar las constantes hacamos: CONST iva = 16 En estos ejemplos se puede ver que hemos usado el signo Igual para "Asignar" a la variable que hay a su izquierda el valor de la "Expresin" que hay a su derecha, por lo tanto ya podemos decir que el signo igual es el operador de asignacin en el lenguaje Basic. En el caso ms sencillo: total = 500 hacemos que en la variable total se almacene el nmero 500, perdindose el valor que tuviera anteriormente. Tambin podemos hacer: total = total + 100 En este caso estamos usando la variable total como un "acumulador" ya que vamos a almacenar en ella el valor que tenga antes de la asignacin ms cien. Dicho de otra forma, si la variable vala 500 ahora le vamos a almacenar su valor de 500 ms 100, con lo que al final de la asignacin pasar a valer 600. En el siguiente apartado se explican algunas cosas sobre estas asignaciones. Es importante tener claro que a una variable solo le podemos asignar los datos adecuados a su tipo, por ejemplo si a una variable de cadena le asignamos una expresin numrica o a una variable numrica le asignamos una cadena se producir un Error de Tiempo de Ejecucin y el programa se parar. Tambin hay que tener en cuenta que si a una variable de tipo entero le asignamos una expresin cuyo valor es con decimales, el nmero almacenado se redondear, por ejemplo... num% = 10 / 3 har que num% valga 3 en vez de 3.3333, igual que num% = 20 / 3

20

har que num% valga 7 en vez de 6.6666. Esta vez se ha redondeado hacia arriba. Tiene que quedar claro que la variable "destino" siempre va a la izquierda del signo igual, y la expresin a la derecha. Las expresiones nunca van a ir solas. Siempre van en una asignacin o en una estructura condicional que ya veremos ms adelante. 1.5.3 - Contadores y acumuladores Estas dos palabras se usan mucho en programacin para referirse a variables que van incrementando su valor a lo largo de la ejecucin del programa. Normalmente sern de tipo numrico y no se tratan de ninguna forma en especial, solo que al asignarles un valor se hace de forma que el anterior no se pierda, por ejemplo: nivel = nivel + 1 total = total + subtotalLinea vidas = vidas - 1 tamao = tamao * 2 Es muy importante inicializarlas de forma correcta siguiendo estas normas: y Si vamos a sumar o restar la inicializaremos a cero al principio del programa para que no empiecen con valores residuales. y Si vamos a multiplicar las inicializamos a 1, porque si valen cero todo lo que multipliquemos por ella seguir valiendo cero. La diferencia entre acumuladores y contadores es que los acumuladores se incrementan con cualquier nmero, como por ejemplo el total de una factura, mientras que los contadores se incrementan siempre con el mismo nmero, normalmente 1. 1.5.4 - Operadores aritmticos Llamamos operadores aritmticos a los signos que usaremos para hacer operaciones aritmticas como sumas, restas, etc.OPERADOR + * / MOD ^ Suma Resta Multiplicacin Divisin Resto de divisin (Mdulo) Potencias NOMBRE

21

El operador suma lo que hace es sumar valores. Se pueden encadenar tantas sumas como queramos, por ejemplo total = 2 + 74 + 7 + 25 + 82 El operador resta resta un valor a otro, por ejemplo: neto = peso - tara El operador asterisco hace multiplicaciones, por ejemplo: elDoble = n * 2 El operador divisin divide un valor entre otro, por ejemplo: kilos = gramos / 1000 El operador MOD nos devuelve el resto de una divisn. Es especialmente til para deducir si un nmero es par, ya que al dividir un par entre 2 el resto siempre es 0. Se usa entre los dos operandos igual que los smbolos anteriores, veremos su funcionamiento y su utilizacin en los temas siguientes. El operador "acento circunflejo" sirve para calcular potencias, por ejemplo 5^2 es cinco al cuadrado o tambin 5*5. Tambin podramos calcular potencias decimales como 4^2.5. Para escribir este smbolo pulsa maysculas y la tecla correspondiente dos veces, oirs un pitido y solo entonces aparecer escrito en la pantalla. Si aparece dos veces borra uno. 1.5.5 - Operadores relacionales o de comparacin Estos operadores hacen que una expresin devuelva un valor lgico, es decir, en vez de un nmero devolver VERDADERO o FALSO. Esto nos ser muy til en las estructuras condicionales que veremos en los siguientes temas, dnde veremos muchos ejemplos de su utilizacin. OPERADOR = > < >= 0) OR (precio = 0)) En este caso la variable puedesComprar sera verdadero si tu dinero es mayor que cero (aprovechamos para dar un ejemplo del operador >) o si el precio es gratis, o las dos cosas. Solo sera falso si no tienes dinero y el producto a comprar vale dinero, con lo que las dos partes de la expresin seran falsas y el resultado tambin. NOT es un operador "monario". Esto significa que slo tiene un operando, a diferencia de los otros que siempre estn entre dos operandos. Lo que hace NOT es invertir el resultado de una expresin, es decir, si es verdadera devuelve falso y si es falsa devuelve verdadero.

23

Para detallar los posibles valores que devuelven los operadores lgicos se construyen las llamadas "Tablas de la verdad" que representan todas las combinaciones posibles y los valores devueltos por cada operador.

TABLA DE LA VERDAD PARA AND VERDADERO VERDADERO FALSO FALSO AND AND AND AND VERDADERO FALSO VERDADERO FALSO = = = = VERDADERO FALSO FALSO FALSO

TABLA DE LA VERDAD PARA OR VERDADERO VERDADERO FALSO FALSO OR OR OR OR VERDADERO FALSO VERDADERO FALSO = = = = VERDADERO VERDADERO VERDADERO FALSO

TABLA DE LA VERDAD PARA NOT NOT NOT VERDADERO FALSO = = FALSO VERDADERO

Observa que la variable puedesComprar y la esNavidad del ejemplo anterior pueden ser de cualquier tipo numrico para poder ser verdaderas o falsas. QBasic entiende que una variable (o el resultado de una expresin) es falsa si vale 0 y verdadera en cualquier otro

24

caso. Otros lenguajes tienen un tipo de datos especfico para estas situaciones, pero aqu puede valer cualquier tipo de datos numrico. Es normal declarar constantes al principio de los programas para poder usar las palabras VERDADERO y FALSO en las expresiones y darle ms claridad. Se hara: CONST FALSO = 0 pero para verdadero podemos hacer... CONST VERDADERO = NOT FALSO con lo que hacemos que VERDADERO sea justo lo contrario de FALSO. Muy lgico.

TEMA 1.6 FUNCIONES INCLUIDAS EN EL LENGUAJEEl lenguaje BASIC incluye un montn de funciones que nos harn algunos clculos sin necesidad de tener que programar nosotros todo lo necesario. Una funcin es una palabra que, insertada dentro de una expresin, llama a un pequeo "programita" que hace los clculos y nos devuelve un resultado. Veamos este ejemplo: CLS INPUT "Escribe un nmero: ", num raiz = SQR(num) PRINT "Su raz cuadrada es ";raiz Este programa nos pide que escribamos un nmero y lo guarda en la variable num. A continuacin calcula la raz cuadrada del nmero usando la funcin SQR y gualda el resultado en la variable raiz para al final escribirlo en pantalla. No hemos tenido que programar ni conocer las operaciones matemticas necesarias para calcular la raz cuadrada de un nmero, lo ha hecho automticamente la funcin. Observa la forma de decirle a la funcin cual es el nmero que queremos que utilice para calcular la raz cuadrada: Lo metemos entre parntesis despus del nombre de la funcin. Este nmero se dice que es un Parmetro que pasamos a la funcin. Si alguna funcin no necesita parmetros no ponemos nada, en otros lenguajes hay que poner los parntesis vacos detrs del nombre de la funcin, pero en QBasic no. El parmetro no tiene por que ser un nmero constante, puede ser a su vez otra expresin. En la instruccin PRINT podemos incluir cualquier expresin, por lo tanto en el ejemplo anterior nos podamos haber ahorrado la variable raz escribiendo directamente: CLS INPUT "Escribe un nmero: ", num PRINT "Su raz cuadrada es "; SQR(num) Las funciones tienen tipo de datos como las variables, es decir, nos devuelven un resultado que puede ser cadena, entero, etc. y por lo tanto pueden llevar un sufijo de identificacin de tipo a continuacin del nombre, por ejemplo la funcin TIMER nos devuelve el nmero de

25

segundos que han pasado desde las doce de la noche en formato numrico: segundos = TIMER mientras que la funcin TIME$ nos devuelve la hora actual en formato de cadena de texto con la hora, los minutos y los segundos separados por dos puntos: horaActual$ = TIME$ PRINT "Son las "; horaActual$ En este caso para guardar el valor devuelto por TIME$ hemos tenido que usar una variable de cadena. Ambas funciones no llevan parmetros porque si lo que hacemos es preguntar la hora no tenemos que decir nada ms, ya la propia funcin ver como saca la hora del reloj interno del ordenador. Si una funcin lleva varios parmetros se pondrn separados por comas dentro de los parntesis, por ejemplo: PRINT STRING$ (20,"Z") La funcin STRING$ devolver una cadena con veinte zetas, es decir "ZZZZZZZZZZZZZZZZZZZZ". Para hacerlo necesita saber dos cosas: cuantas y cual letra tiene que repetir, por eso le damos dos parmetros separados por una coma. Observa tambin en el ejemplo que el primer parmetro debe de ser un nmero (o una expresin numrica) y el segundo tiene que ser una cadena (o una expresin de cadenas). Para saber de qu tipo es cada parmetro y el tipo del resultado que devuelve la funcin es muy importante consultar la ayuda de QBasic todas las veces que haga falta. Si intentamos pasar parmetros de otro tipo se producir un error de tipos y el programa se parar. Tambin se producir un error de "Llamada a funcin no vlida" si la funcin no es capaz de hacer los clculos con los parmetros que le hemos pasado, aunque sean del tipo correcto. Por ejemplo, sabemos que no existe raz cuadrada para los nmeros menores que cero, por lo que se producir un error de este tipo si hacemos PRINT SQR (-14) En caso de que pasemos como parmetro una expresin, por ejemplo PRINT SQR(miVariable) hay que tener mucho cuidado de que esta expresin no pueda llegar a valer menos que cero. Estas son algunas de las funciones ms usadas. En temas posteriores irn apareciendo ms. Para verlas todas y todos los tipos de datos que necesitan y devuelven mira la ayuda del QBasic.FUNCIN SQR(num) DESCRIPCIN Raz cuadrada Pasa a entero qitando decimales EJEMPLO SQR(16) devuelve 4

INT(decimal)

INT(1.6) devuelve 1

26

CINT(decimal)

Redondea a entero (Max = 32767) Redondea a entero largo Calcula el seno Calcula el coseno Calcula la tangente Devuelve la longitud de la cadena Devuelve una cadena sin espacios al final Devuelve la cadena pasada a maysculas (No funciona col la ni con los acentos) Devuelve una subcadena del tamao indicado a parir de la posicin indicada. Devuelve una cadena formada por un nmero de caracteres repetidos Devuelve la hora actual como cadena Devuelve la fecha actual como cadena en formato mes-dia-ao Devuelve la letra de la

CINT(1,6) devuelve 2

CLNG(decimal)

CLNG(100000.2) devuelve 100000

SIN(num)

SIN(40) devuelve 0.64278

COS(num)

COS(40) devuelve 0.76604

TAN(num)

TAN(40) devuelve 0.839009

LEN(Cadena)

LEN("RONDA") devuelve 5

RTRIM(Cadena)

RTRIM("Fin. "Fin."

") devuelve

UCASE$(Cadena)

UCASE$("Toma Castaa") devuelve "TOMA CASTAA"

MID$(Cadena, inicio, largo)

MID$("Programacin",5,4) devuelve "rama"

STRING$(largo, carcter)

STRING$(10,"#") devuelve "##########"

TIME$

Devuelve por ejemplo "16:45:08"

DATE$

Devuelve por ejemplo "0120- 2011"

INKEY$

Devolvera "A" si la ltima tecla pulsada fue la "A

27

ltima tecla pulsada antes de llegar a ejecutar la funcin.

mayscula"

En una de las ampliaciones de este curso se habla de un conjunto de funciones muy tiles para el manejo de cadenas y en otro se explica en detalle la funcin INKEY$ que es especialmente til para detectar teclas pulsadas en mens, juegos, preguntas que se responden con s o no, etc.

TEMA 1.7 ESTRUCTURAS CONDICIONALES IFy y y y y y y

1.7.1 1.7.2 1.7.3 1.7.4 1.7.5 1.7.6 1.7.7

-

Introduccin a los bloques de control Alternativa simple. Instruccin IF Sangra Anidacin Instruccin IF simplificada Alternativa doble. Instruccin IF-THEN-ELSE Alternativa mltiple. Instruccin ELSEIF

1.7.1 - INTRODUCCIN A LOS BLOQUES DE CONTROL Hasta ahora al ejecutar nuestros programas se han ejecutado todas las instrucciones que aparecen en el listado del cdigo fuente del programa, desde la primera hasta la ltima. A partir de ahora vamos a poder conseguir que una o varias instrucciones solo se lleguen a ejecutar si se cumple una condicin, que si no se cumple se ejecuten otras, o incluso que algunas instrucciones se ejecuten ms de una vez (Esto lo veremos en los siguientes temas). 1.7.2- ALTERNATIVA SIMPLE. INSTRUCCIN IF Empecemos con un ejemplo. Un programa que nos pida la nota de un examen y nos felicite si est aprobado. CLS INPUT "Escribe la nota del examen: ", nota IF nota >= 5 THEN PRINT "Enhorabuena, has aprobado." END IF PRINT "Gracias por usar el programa." Ahora ejecutemos el programa. Hemos sacado un 7: Escribe la nota del examen: 7 Enhorabuena, has aprobado. Gracias por usar el programa. Volvamos a lanzar el programa, esta vez hemos sacado un 4: Escribe la nota del examen: 4 Gracias por usar el programa. Esta ltima vez se ha saltado una de las instrucciones del listado Por qu?

28

Porque hemos usado la instruccin IF (si en ingls), una de las ms importantes de todo lenguaje de programacin estructurado, y le hemos puesto como condicin que el valor almacenado en la variable nota sea mayor o igual que cinco con lo que hacemos que todas las instrucciones que haya entre IF y END IF solo se ejecuten si esta expresin es VERDADERA. Vamos a ver con ms tranquilidad la sintaxis de la instruccin IF IF condicin THEN instrucciones END IF SI la condicin es VERDADERA, ENTONCES (THEN) se ejecutarn las instrucciones hasta llegar a END IF (FIN SI). Despus se seguir con el resto del programa Si la condicin es falsa se saltar todo el bloque IF y se ejecutarn las siguientes instrucciones del programa que haya despus del END IF. 1.7.3 - SANGRA En el ejemplo anterior puedes ver que las instrucciones que hay dentro del bloque IF estn escritas un poco ms a la derecha que las dems, no justo en el margen izquierdo. Esto se hace por comodidad, para poder saber de un vistazo cuales son las instrucciones que hay dentro del bloque. En la mayora de lenguajes no es obligatorio (En COBOL s), pero siempre es muy recomendable hacerlo as para dar mayor claridad al cdigo fuente del programa. Para hacer esto basta con pulsar la tecla TABULADOR antes de escribir la instruccin, mejor que escribir espacios. En las opciones de QBasic se puede especificar el tamao de la tabulacin (Cuantos espacios se escriben). Por defecto tiene 8, pero es mejor un nmero ms bajo entre 3 y 5 como ya veremos ms adenante. Esta tcnica tambin se conoce como encolumnado o indentacin (En ingls se llama indent). 1.7.4 - ANIDACIN Como hemos visto en la sintaxis de la instruccin IF, dentro del bloque de instrucciones a ejecutar se puede usar cualquier instruccin, por lo tanto tambin se pueden usar otras instrucciones IF. A esto es a lo que se llama anidacin de instrucciones. Veamos un ejemplo que nos diga si un nmero es par (usando el operador MOD) y en este caso nos diga tambin si el nmero es mayor que 10: CLS INPUT "Escribe un nmero: ", num IF num MOD 2 = 0 THEN PRINT "Es un nmero par" IF num > 10 THEN PRINT "Es mayor que 10" END IF END IF

29

Ejemplos de la ejecucin de este programa pueden ser... Escribe un nmero: 7 Escribe un nmero: 8 Es un nmero par Escribe un nmero: 12 Es un nmero par Es mayor que 10 Aqu si la primera condicin se cumple se escribe "Es par" y adems se hace otra comprobacin que se podr cumplir o no. Nunca se va a llegar a la segunda comprobacin si la primera no se ha cumplido. Es muy importante observar que cada IF lleva su END IF correspondiente y que el bloque de instrucciones del segundo IF est encolumnado todava ms a la derecha que el anterior. Cuando escribimos un programa en papel es comn unir con una lnea cada IF con su END IF para aclarar el listado.

1.7.5 - INSTRUCCIN IF SIMPLIFICADA Si el bloque de instrucciones de una instruccin IF slo va a llevar una instruccin podemos escribirla en la misma lnea detrs del THEN y ahorrarnos el END IF. Para el ejemplo del examen podamos haber hecho: CLS INPUT "Escribe la nota del examen: ", nota IF nota >= 5 THEN PRINT "Enhorabuena, has aprobado." PRINT "Gracias por usar el programa." Esto es til en algunos casos, pero si vemos que nos vamos a liar es mejor poner el END IF como hemos visto antes, aunque si nos acostumbramos a poner siempre los encolumnados no hay por qu equivocarse. 1.7.6 - ALTERNATIVA DOBLE. INSTRUCCIN IF-THEN-ELSE En el ejemplo del examen estara bien que "si no" aprueba, decirle que ha suspendido. Lo podemos hacer de esta forma: CLS INPUT "Escribe la nota del examen: ", nota IF nota >= 5 THEN PRINT "Enhorabuena, has aprobado." ELSE PRINT "Lo siento, has suspendido." END IF PRINT "Gracias por usar el programa."

30

En este caso se comprueba la condicin del IF. Si es verdadera se ejecuta su bloque de instrucciones y despus se sigue con lo que venga detrs del END IF, igual que antes. Ahora viene lo nuevo, si la condicin no se cumple se ejecuta el bloque de instrucciones del ELSE hasta el END IF, y despus se sigue con lo que haya detrs. De esta forma nos aseguramos de que siempre se ejecuta uno y solo uno de los dos bloques de instrucciones segn la condicin sea verdadera o falsa. Dentro del bloque del ELSE tambin puede ir cualquier tipo de instruccin, incluido otro bloque IF o del tipo que sea. Veamos un ejemplo "especialmente malo" de un programa que nos diga el nombre de un mes a partir de su nmero. En temas posteriores simplificaremos bastante este problema. CLS INPUT "Escribe el nmero del mes: ", mes IF mes = 1 THEN PRINT "Enero" ELSE IF mes = 2 THEN PRINT "Febrero" ELSE IF mes = 3 THEN PRINT "Marzo" ELSE IF mes = 4 THEN PRINT "Abril" ELSE IF mes = 5 THEN PRINT "Mayo" ELSE IF mes = 6 THEN PRINT "Junio" ELSE IF mes = 7 THEN PRINT "Julio" ELSE IF mes = 8 THEN PRINT "Agosto" ELSE IF mes = 9 THEN PRINT "Septiembre" ELSE IF mes = 10 THEN PRINT "Octubre" ELSE IF mes = 11 THEN PRINT "Noviembre"

31

ELSE IF mes = 12 THEN PRINT "Diciembre" ELSE PRINT "Mes no vlido" END IF END IF END IF END IF END IF END IF END IF END IF END IF END IF END IF END IF PRINT "S'ACAB" Muy sencillo: Si es enero lo escribimos, si no miramos si es febrero, si no a ver si es marzo, etc. as hasta diciembre. Si no es diciembre sacamos un mensaje de mes no vlido. Observa que cada IF tiene su ELSE y su END IF correspondiente abajo. Normalmente nunca llegaremos a estas estructuras tan anidadas, pero aqu se puede ver la importancia de que el tamao de tabulacin no sea muy grande. Observa que si haces que la ventana del navegador sea ms estrecha podra pasar (segn los programas) que algunas lneas de las ms largas pasan abajo y se nos estropea toda nuestra jerarqua. En QBasic y en los otros editores de programacin esto no ocurre porque no tienen salto de lnea automtico para que no pase eso, pero de todas formas es muy incmodo tener que ir moviendo la barra de desplazamiento horizontal a izquierda y derecha para ver nuestro listado. 1.7.7 - ALTERNATIVA MLTIPLE. INSTRUCCIN ELSEIF Vamos a arreglar un poco el ejemplo anterior para no tener tantos END IF. CLS INPUT "Escribe el nmero del mes: ", mes IF mes = 1 THEN PRINT "Enero" ELSEIF mes = 2 THEN PRINT "Febrero"

32

ELSEIF mes = 3 THEN PRINT "Marzo" ELSEIF mes = 4 THEN PRINT "Abril" ELSEIF mes = 5 THEN PRINT "Mayo" ELSEIF mes = 6 THEN PRINT "Junio" ELSEIF mes = 7 THEN PRINT "Julio" ELSEIF mes = 8 THEN PRINT "Agosto" ELSEIF mes = 9 THEN PRINT "Septiembre" ELSEIF mes = 10 THEN PRINT "Octubre" ELSEIF mes = 11 THEN PRINT "Noviembre" ELSEIF mes = 12 THEN PRINT "Diciembre" ELSE PRINT "Mes no vlido" END IF PRINT "S'ACAB" A la Palabra Clave ELSE le hemos colocado directamente la otra condicin para simplificar un poco el Algoritmo, pero viene a ser prcticamente lo mismo. Veamos la sintaxis de forma un poco ms clara: IF condicin THEN bloqueInstrucciones ELSEIF otra condicin THEN bloqueInstrucciones ELSE bloqueInstrucciones END IF Si la condicin del IF se cumple se ejecutan sus instrucciones y ya est. Si no, se comprueba la condicin del primer ELSEIF y si es verdadera se ejecutan sus instrucciones y ya est. Si no, se comprueba la condicin del siguiente ELSEIF y si es verdadera se ejecutan sus instrucciones y ya est. Si la condicin del ltimo ELSEIF no se cumple se ejecuta el bloque ELSE si existe. Puede haber tantos bloques ELSEIF con su condicin como sea necesario, pero solo un bloque ELSE (o ninguno) al final. Si no hay bloque ELSE puede suceder que no se ejecute nada porque no se cumpla ninguna de las condiciones. Las condiciones no tienen que estar relacionadas de ninguna forma, aqu siempre hemos preguntado por el mes, pero podamos haber comprobado cualquier otra cosa, o poner los meses desordenados.

33

Esta estructura ELSEIF no se usa mucho y no existe en algunos otros lenguajes de programacin, en su lugar se usan los IF anidados como vimos en el ejemplo largusimo anterior o la estructura SELECT que veremos en el tema siguiente. Una ltima cosa antes de acabar con los IF. Si escribimos ENDIF todo junto, QBasic y Visual Basic nos lo corrigen automticamente. Esto es porque en alguna versin muy antigua del lenguaje BASIC se escriba as.

34

TEMA 1.8 ESTRUCTURA DE SELECCIN SELECTEn el ejemplo de instrucciones IF anidadas nos sala un pedazo de listado para decir el nombre del mes. Despus lo arreglamos un poco con las instrucciones ELSEIF. Ahora vamos a hacerlo todava un poco mejor. CLS INPUT "Escribe el nmero del mes: ", mes SELECT CASE mes CASE 1 PRINT "Enero" CASE 2 PRINT "Febrero" CASE 3 PRINT "Marzo" CASE 4 PRINT "Abril" CASE 5 PRINT "Mayo" CASE 6 PRINT "Junio" CASE 7 PRINT "Julio" CASE 8 PRINT "Agosto" CASE 9 PRINT "Septiembre" CASE 10 PRINT "Octubre" CASE 11 PRINT "Noviembre" CASE 12 PRINT "Diciembre" CASE ELSE PRINT "Mes no vlido" END SELECT PRINT "S'ACAB" Hemos usado una estructura nueva: La instruccin SELECT. Esta estructura es equivalente a las anteriores de IF anidados, pero es ms fcil de manejar y el programa queda ms estructurado. Si has entendido la estructura IF no te ser muy difcil entender esta. Lo primero es escribir las Palabras Clave SELECT CASE seguidas de una expresin. Esta expresin es normalmente simplemente una variable que puede ser de cadena o numrica. En este caso no tiene que devolver VERDADERO o FALSO como en los IF ya que no se usan operadores relacionales ni lgicos, solo los aritmticos cuando hace falta. A continuacin para cada resultado posible se pone la Palabra Clave CASE y la expresin a comparar con la del principio. Si la comparacin es verdadera se ejecuta el bloque de instrucciones entre

35

este CASE y el siguiente y se sale de la estructura. Si la condicin es falsa se ejecuta el bloque del CASE ELSE si existe y si no nada. Las expresiones de los cases se pueden poner de una de las siguientes formas: CASE 1 Una expresin (En este caso un nmero), igual que en el ejemplo. CASE 1, 2, 3 Varias expresiones separadas por comas. CASE 1 TO 3 Un intervalo de valores, ambos inclusive, separados por la palabra clave TO. En este caso si la expresin inicial era de tipo entero sern vlidos los resultados 1, 2 y 3, pero si era de tipo real sern vlidos todos los nmeros posibles entre el 1 y el 3 como por ejemplo el 1.517512 y el 2.17521. CASE IS > 2 CASE IS = 5 CASE IS 8 CASE IS ". Esta instruccin nos puede resultar algo til en los programas que hemos hecho hasta ahora ya que la informacin se escribe en pantalla una lnea debajo de otra, pero cuando hagamos diseos de pantallas ms elaborados ya no ser recomendable usar esta instruccin porque el listado de directorio se saltar todas nuestras especificaciones de pantalla, incluso ahora si el listado es muy largo slo se ven las ltimas lneas. Si usamos la orden FILES sin parmetros se mostrarn todos los ficheros y subdirectorios del directorio activo, pero podemos especificar rutas, nombres de archivos y caracteres comodn (? y *) para adecuar el listado a nuestras necesidades. Veamos unos cuantos ejemplos: FILES "*.txt" Lista todos los ficheros con extensin TXT que haya en el directorio activo. FILES "JUEGO.*" Lista todos los ficheros que se llamen JUEGO, sea cual sea su extensin, del directorio activo. FILES "C:\BASIC\PROGS\*.*" Lista todos lo que haya en el directorio BASIC\PROGS de la unidad C:. FILES "Imagen?.BMP" Lista todos los archivos cuyo nombre empiece por "Imagen" y vaya seguido por exactamente un carcter, su extensin sea BMP y stn en el directorio activo. Apareceran por ejemplo los archivos Imagen2.BMP o Imagen7.BMP, pero nunca el archivo Imagen14.BMP ya que contiene dos nmeros. Si la orden FILES no encuentra nada que listar se produce un error de tiempo de ejecucin. Si listamos un directorio vaco no se producir ningn error. Ya hemos visto como borrar directorios, ahora vamos a ver como borrar archivos: KILL Archivo$ Esta instruccin borra archivos, podemos usar una ruta y/o los comodines * y ?, cosa que puede ser peligrosa porque se borraran varios ficheros a la vez, una vez ms recomendar prudencia al usar esta orden para evitar estropicios irreparables, ya que en MS-DOS normalmente no tenemos papelera de reciclaje. Si no especificamos una ruta se entender que estamos trabajando sobre el directorio activo. Si el archivo que queremos borrar no existe se producir un error de tiempo de ejecucin. No confundir esta instruccin con la orden KILL de Linux que detiene procesos, es decir, obliga a terminar la ejecucin de un programa pero no borra nada del disco. Por ltimo vamos a ver como cambiar el nombre un fichero: NAME viejo$ AS nuevo$

103

viejo$ es el nombre actual del archivo que queremos renombrar, que debe existir para que no se produzcan errores. nuevo$ tiene que ser el nuevo nombre que le vamos a dar al archivo, y que no debe existir todava. Por ejemplo, para cambiar el nombre al archivo base.dat del directorio actual por base.bak tendramos que usar la instruccin NAME base.dat AS base.bak En el nombre del archivo ya existente (la primera parte antes de AS) podemos especificar una ruta de directorios. Para copiar o mover archivos no tenemos una instruccin especfica en QBasic. Tendremos que crearnos un modulo que lo abra en modo binario y lo copie carcter por carcter en un archivo nuevo en la otra ubicacin, si lo que queramos era moverlo despus habr que borrar el original. Para hacer esto y otras cosas ms complicadas puede ser ms cmodo llamar a la orden correspondiente de MS-DOS como se ver en temas posteriores.

TEMA 1.17 CONTROL DE ERRORESy 1.17.1 - Instruccin GOTO. La ms conocida y odiada de BASIC y 1.17.2 - Introduccin a los errores y 1.17.3 - Control de errores 1.17.1 - INSTRUCCIN GOTO. LA MS CONOCIDA Y ODIADA DE BASIC Empecemos con un ejemplo "muy malo": CLS Pricipio: PRINT "Esto es el principio" GOTO Final Enmedio: PRINT "Esto es lo de en medio, pero no lo vers" Final: PRINT "Esto es el Final" Que dara como resultado en pantalla: Esto es el principio Esto es el final Ahora veamos como funciona: y Borra la pantalla. y Pasa por una etiqueta definida como Principio. y Escribe "Esto es el principio" y Busca una etiqueta que se llame "Final" y cuando la encuentra salta y sigue a partir de all. y Escribe "Esto es el final". y Como no hay nada ms, el programa termina. En este programa hemos definido tres etiquetas. Para definir etiquetas usamos las mismas normas que para los nombres de variables y al final le colocamos el carcter dos puntos (:). Las etiquetas siempre van al principio de la lnea y si usamos etiquetas es

104

til encolumnar todas las dems instrucciones ms a la derecha, para verlas al vuelo. Podemos definir etiquetas en cualquier mdulo de nuestro programa, pero QBasic solo las "encontrar" si estn definidas en el mdulo principal. Por esto no tiene sentido definir etiquetas dentro de procedimientos y funciones. Las etiquetas no hacen nada, simplemente estn ah. nicamente nos sirven para poder "Saltar" a ellas usando instrucciones especiales como la famosa GOTO (Go to..., ir a...) que salta incondicional e inmediatamente a la etiqueta que le indiquemos para seguir desde all con la ejecucin del programa. Sencillo No?. En verdad es muy sencillo pero puede dar lugar a toda una variedad de problemas lgicos que pueden ser casi imposibles de detectar, aislar y solucionar. Imagina un programa donde en vez de tres etiquetas haya trescientas y entre ellas haya centenares de instrucciones GOTO que dirigen la ejecucin del programa a un sitio lejano de nuestro listado. Una mala planificacin del programa seguramente har que bloques enteros no se lleguen a ejecutar nunca o que se produzcan bucles infinitos que lleguen a bloquear el programa. Por eso a los programas que usan estas instrucciones se les conoce como "Cdigo Espagueti". En los lenguajes de bajo nivel como es el caso de los ensambladores y en lenguajes de guiones muy sencillos como el que se utiliza para construir los ficheros .BAT de MS-DOS se usan intensivamente las etiquetas y las instrucciones de bifurcacin o salto incondicional, pero los modernos lenguajes de programacin estructurada (QBasic lo es) nos dan la posibilidad de usar estructuras de control iterativas (Bucles PARA, MIENTRAS y REPETIR), as como los procedimientos y las funciones que nos permiten en todo caso saber como funciona nuestro programa para poder solucionar posibles errores. Por esto es muy recomendable EVITAR A TODA COSTA EL USO DE ESTA METODOLOGA DE PROGRAMACIN CON INSTRUCCIONES GOTO Y SIMILARES en los lenguajes de alto nivel, salvo en el caso de las instrucciones de manejo de errores que vamos a ver en los siguientes apartados y que son el motivo de esta explicacin. 1.17.2 - INTRODUCCIN A LOS ERRORES Hemos ido viendo a lo largo de los temas anteriores que hay tres tipos de errores: y Errores de compilacin y Errores de tiempo de ejecucin y Errores lgicos Los primeros suelen ser cosas mal escritas o que no cumplen con las normas de sintaxis del lenguaje de programacin. La mayora de ellos en QBasic sern mostrados conforme vamos escribiendo nuestro cdigo al pasar de lnea, o en todo caso al intentar ejecutar el programa. Tendremos que corregirlos modificando lo que este mal para poder iniciar el programa.

105

Los errores de tiempo de ejecucin se producen durante la ejecucin del programa y son provocados por intentar hacer algo que no est permitido, como dividir entre cero, o bien porque alguno de los dispositivos del ordenador falle (Memoria agotada, no se encuentra un fichero, la impresora no tiene papel, etc...). Estos errores hacen que el programa se detenga. En QBasic se volver al editor y se mostrar un recuadro con el mensaje apropiado. En otros lenguajes o en programas ya compilados puede salir desde un simple mensaje hasta una pantalla azul tpica de Windows o lo ms normal es que el ordenador deje de responder y haya que reiniciarlo. Los errores lgicos se deben a una mala planificacin de los algoritmos, lo que da lugar, en el mejor de los casos, a que el programa funcione correctamente pero no haga lo que queremos y no resuelva el problema para el que ha sido diseado, o lo ms normal es que llegue a provocar un error de tiempo de ejecucin porque se llene el espacio disponible en memoria o se entre en un bucle infinito. En este tema vamos a ver cmo conseguir que cuando se produzca un error de tiempo de ejecucin el programa no quede detenido inmediatamente, sino que se salga de l de una forma un poco ms "elegante" o incluso se pueda solucionar el problema y seguir normalmente con la ejecucin del programa. Usando las tcnicas de programacin estructurada que hemos visto en este curso hasta antes del tema de ficheros si hacemos los programas bien NO TIENEN PORQU PRODUCIRSE ERRORES DE TIEMPO DE EJECUCIN. Nosotros somos los responsables de evitar que los bucles sean infinitos, de no hacer referencias a ndices de arrays que no existen, de que nada se llegue a dividir entre cero, etc... La nica fuente potencial de errores son los datos que pedimos al usuario, pero si depuramos los datos de entrada de forma que no se acepten valores no permitidos como vimos en el tema de bucles podemos asegurar en la amplia mayora de los casos que nuestro programa va a funcionar bien siempre, ya que solo acepta datos vlidos. El problema llega cuando empezamos a trabajar con dispositivos externos como son las unidades de disco donde se guardan los ficheros. Por muy bien hecho que est nuestro programa no podemos evitar que el usuario quiera abrir un fichero que no existe, o de un disquete que todava no ha introducido en la unidad correspondiente, o que se ha estropeado, que quiera escribir en un CD-ROM, en un disco que no tiene espacio suficiente o que est protegido contra escritura. Slo en este caso de los ficheros y en otros tambin especiales como cuando veamos cmo usar las impresoras ser necesario y recomendable programar rutinas de manejo de errores de las que vamos a ver en el siguiente apartado. En otros casos no nos merece la pena usar esto ya que las instrucciones GOTO ofrecen una forma especialmente mala de estructurar los programas y podemos despreciar la posibilidad de que se produzca algn error raro como

106

que se agote la memoria por culpa de otro programa y el nuestro no pueda seguir funcionando. 1.17.3 - CONTROL DE ERRORES Para activar el control de errores en QBasic usaremos la siguiente instruccin: ON ERROR GOTO linea Dnde linea es el nombre de una etiqueta que se haya definido en el programa principal. Esto quiere decir "Cuando se produzca un error ve inmediatamente a la etiqueta que se llama linea y sigue desde all". De esta forma conseguimos que el programa no se detenga inmediatamente al producirse un error. Como hemos dicho antes, solo debemos controlar los errores en instrucciones peligrosas como es el caso de las que abren los ficheros (OPEN). Una ver pasadas estas instrucciones debemos desactivar el manejo de errores usando la instruccin: ON ERROR GOTO 0 Lo ltimo de esta instruccin es un cero. A partir de ahora cuando se produzca un error ya no habr manejo de errores y el programa se detendr, pero si lo hemos hecho bien no tienen porqu producirse errores. Lo normal es activar el manejo de errores al principio de un procedimiento que, por ejemplo, abra un fichero y desactivarlo al final, antes de salir. De esta forma tenemos claramente delimitado donde usamos el manejo de errores, que estar activo solo mientras se ejecute ese mdulo, y no en el resto del programa que no usa instrucciones "conflictivas". Vamos con un ejemplo completo: 'Programa principal CLS INPUT "Nombre del fichero: ", fich$ MuestraTamanno fich$ END manejaerrores: SELECT CASE ERR CASE 53 PRINT "No CASE 68 PRINT "No CASE 71 PRINT "No CASE 76 PRINT "No CASE ELSE PRINT "Se END SELECT

se ha encontrado el archivo" se ha encontrado la unidad de disco" se ha encontrado el disco en la unidad" se ha encontrado el directorio" ha producido el error"; ERR

107

END 'Este procedimiento abre el archivo, muestra el tamao y cierra 'Entrada: f$: El nombre del archivo SUB MuestraTamanno (f$) ON ERROR GOTO manejaerrores OPEN f$ FOR INPUT AS #1 PRINT "El fichero ocupa"; LOF(1); "bytes." CLOSE ON ERROR GOTO 0 END SUB Este programa pide al usuario que escriba el nombre de un fichero para abrirlo y mostrar su tamao usando la funcin LOF que ya conocemos. Si escribimos un nombre de archivo vlido no se activa para nada el manejo de errores y el programa funciona normalmente, nos calcula el tamao en bytes del archivo y termina al llegar a la instruccin END que hay justo despus de la llamada al procedimiento. El resultado podra ser: Nombre del fichero: c:\autoexec.bat El fichero ocupa 219 bytes. Veamos como funciona el programa paso a paso en caso de que el fichero exista y no se produzca el error: y Entramos al mdulo principal. y Borramos la pantalla con CLS. y Pedimos al usuario que escriba el nombre de un fichero y lo guardamos en la variable fich$: y Entramos al procedimiento Muestratamanno y le pasamos la variable fich$ que contiene el nombre que ha escrito el usuario. y Ya dentro del procedimien