QBASIC I

EL QBASIC ES SENCILLO Y NO REQUIERE UNA ESTRUCTURA BÁSICA

Veamos en un momento como sería 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");

               return(0);

}

Podemos ver que en los dos están 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 símbolos y esas otras palabras tan raras?...

En otros lenguajes de programación hace falta escribir un "esqueleto básico" donde montar las instrucciones, en QBasic no. Nos limitamos a escribir lo que queremos que haga el programa y ya está.

Estas estructuras básicas son necesarias en los otros lenguajes más avanzados, pero en QBasic como sólo vamos a aprender así lo tenemos más fácil sin tener que escribir cosas que todavía no entendemos.

ESCRIBIR COMENTARIOS

Se usan comentarios dentro del listado del programa para explicar su funcionamiento. Lo que pongamos en los comentarios no altera para nada el funcionamiento del programa.

Los comentarios Ayudan a documentar el programa, sobre todo cuando son programas largos

En QBasic para escribir un comentario ponemos un apóstrofo ('). Veamos el ejemplo con comentarios:

'               Nombre: PROGRAMA HOLA MUNDO

'               Sirve para: Escribe en la pantalla "Hola Mundo"

'               Hecho por : Kike Barrueto  2005 Agosto 10

'               

CLS                                                       'Borra la pantalla

PRINT "Hola Mundo"                            'Escribe "Hola mundo"

Una cabecera describiendo el programa y a continuación 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 más complicadas.

El formato de la cabecera vendrá especificado en el proyecto, por ejemplo que contenga el nombre del programa, una descripción corta, el autor y la fecha. En nuestros programas no es necesario ser tan estrictos.

Una Idea: poner comentarios para que un trozo de programa no se ejecute.

'               Cls

'               Print "Hola Mundo" este programa no hace nada

VARIABLES

Vamos a escribir un programa un poco más complicado que nos pregunte nuestro nombre y nos salude. El resultado (lo que se ve en pantalla al ejecutarlo) podría ser el siguiente:

¿Cómo te llamas? Kike

Hola Kike

El programa borrará la pantalla luego nos preguntará por nuestro nombre, nos dejará escribirlo con el teclado y cuando lo hagamos lo guardará en "algún sitio", después escribirá "Hola " seguido de nuestro nombre que lo habrá sacado del "sitio" donde lo guardó antes.

Vamos a ver como será el código:

CLS

INPUT "¿Cómo te llamas? ", nombre$

PRINT "hola "; nombre$

Ahora tenemos una instrucción nueva, INPUT, que lleva dos parámetros separados por una coma. Esta instrucción 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 "¿Cómo 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 dónde vamos a guardar lo que ha escrito el usuario y que le hemos llamado nombre$ para después poder localizarlo.

La siguiente instrucción, PRINT, es la misma que en el anterior programa. Lo que hace es escribir lo que lleva detrás. En esta ocasión va a escribir dos cosas, primero "Hola " con su espacio detrás tal como aparece dentro de las comillas, y a continuación todo seguido 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 más importantes de los lenguajes de programación. Los programas van a manejar datos que estarán grabados en la memoria del ordenador. Si no existieran las variables tendríamos que saber en que posición exacta los guardamos y después para recuperarlos habría que escribir los números 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í más sencillo usaremos los nombres de variables y QBasic se encargará de ver en que lugar físico de la memoria mete la información y después de saber recuperarla cuando se la pidamos.

TIPOS DE DATOS

Nuestros programas van a poder trabajar con varios tipos de información, como son letras, números 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 números más o menos grandes, por ejemplo.

Veamos ahora los tipos de datos que hay en QBasic.

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, códigos postales, números de teléfono, DNIs, matrículas, etc. tendremos que usar una variable de tipo Cadena (STRING) cuyo nombre llevará al final el carácter $.

Para guardar números tendremos que usar alguno de los otros cuatro tipos de variables.

Si nuestros números no van a llevar decimales usaremos una variable de tipo entero (INTEGER) que ocupa poca memoria (2 bytes) y además el ordenador trabaja con ellas muy rápido.

Si los números 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 números mayores que dos mil millones.

Si vamos a usar números reales (que pueden llevar decimales) tendremos que usar variables de precisión sencilla (SINGLE).

Para algún cálculo que necesite obtener resultados con muchos decimales usaremos las variables de doble precisión (DOUBLE) que son más lentas de manejar y ocupan más memoria que las anteriores.

Si intentamos guardar en una variable un valor más grande (o más pequeño si es negativo) de lo que permite su tipo de datos, se producirá un "Error de Tiempo de Ejecución" y el programa se parará.

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:

• Deben tener entre 1 y 40 caracteres.
• Pueden incluir letras y números.
• No pueden llevar la ñ ni letras acentuadas.
• El primer carácter tiene que ser una letra.

Estos nombres de variable son válidos.

• Edad
• fechaNacimiento
• jugador1
• iva16porCiento
• vidasRestantes

Estos otros nombres no son válidos

• 2jugadores (No empieza por una letra)
• año (Contiene la ñ)
• elPatioDeMiCasaEsParticularYCuandoLlueveSeMoja (Muy Largo)
• puntuación (Lleva acento)

Hay que tener en cuenta que QBasic no distingue de mayúsculas y minúsculas, por lo tanto una variable que se llame nivel será la misma que Nivel, NIVEL o niVEL. De hecho cuando cambiemos las mayúsculas y minúsculas de una variable se cambiarán todas las que ya haya escritas en el resto del programa, es decir, si hemos escrito en un sitio puntos y después escribimos PuntoS en otro sitio, la anterior también se cambiará a PuntoS.

Por convenio los nombres de las variables se escriben todo en minúsculas para diferenciarlos visualmente de las Palabras Claves que se van poniendo en mayúsculas automáticamente. Si una variable lleva dos palabras se suele escribir la primera letra de la segunda palabra en mayúsculas para separar un poco, por ejemplo nombreJugador totalActivo o nuevoRegistro.

En las variables que deberían llevar la “ñ” hay varias formas: Para año 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.

DECLARACIÓN DE VARIABLES

En otros lenguajes de programación (la mayoría) hay que Declarar las variables al principio del programa. Esto significa escribir una instrucción 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 ¿Cómo sabe QBasic del tipo que queremos que sea la variable?

En la tabla de tipos de datos había una columna que ponía Sufijo y que para cada tipo de datos tenía un símbolo distinto.

Para indicar el tipo escribiremos uno de estos sufijos detrás del nombre de la variable, por ejemplo si nombre va a contener texto escribiremos nombre$ (Como hicimos en el ejemplo). A esto se llama declaración implícita, ya que dentro del nombre va incluído 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

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 Lógica, es decir, el programa funciona perfectamente, pero a lo mejor no hace lo que esperábamos. Para evitar esto hay que poner a las variables nombres más descriptivos, y si en este caso de verdad queríamos dos variables es mejor ponerles nombres distintos para evitar confusiones.

En la práctica a partir de ahora vamos a poner el sufijo $ a las variables de cadena y las demás las dejamos sin sufijo para que sean reales que admiten números muy grandes con o sin decimales. Si fuéramos a hacer programas muy depurados sería conveniente usar los otros tipos de variables cuando fuera necesario para que fueran más eficientes con el consumo de memoria.

Las variables al ser usadas la primera vez antes de asignarles (guardar en ellas) ningún valor contienen un texto de longitud cero si son de cadena o el número 0 si son de otro tipo. En otros lenguajes de programación esto no es así y contienen cualquier valor que hubiera en esa posición 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 línea donde su nombre aparece por primera vez) hasta que el programa termina, después su valor se pierde. No podemos contar con que tengamos valores en memoria guardados de la vez anterior que ejecutamos el programa.

LEER DESDE EL TECLADO (INPUT)

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 más tranquilidad.

Su sintaxis más común sería:

INPUT "Pregunta al usuario", variable

·         "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 expresión, solamente una cadena entre comillas. En otros lenguajes de programación no se da esta posibilidad y hay que escribir un rótulo justo antes usando otra instrucción.

·         variable es el nombre de la variable dónde se almacenará la información que escriba el usuario.

Al ejecutar esta instrucción 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 instrucción que haya.

El usuario podrá desplazarse con las flechas del teclado por el texto que está escribiendo para corregir algún 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 "¿Cómo te llamas?",variable$

El resultado después de que el usuario termine de escribir sería

¿Cómo te llamas?Kike

Pero si lo ponemos con el espacio al final...

INPUT "¿Cómo te llamas?  ",variable$

El resultado es parecido pero se ve mejor

¿Cómo te llamas?  Kike

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 numérico 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 indicación alguna, solo el cursor, hay que poner las comillas vacías, por ejemplo...

INPUT "", nombre_variable

Esto puede ser útil cuando la pregunta que hacemos al usuario incluye algún cálculo o expresión de cadena. Como INPUT no permite evaluar expresiones en la pregunta al usuario, esta pregunta habrá que mostrarla antes en una instrucción PRINT normal de las que veremos más adelante con su punto y coma al final, y a continuación poner el INPUT de esta forma para leer la información del usuario.

ESCRIBIR EN PANTALLA - PRINT

Como ya hemos dicho, la forma más básica de dar al usuario los resultados de nuestro programa es a través de la pantalla.

En temas posteriores se explica como 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 línea más baja de la pantalla todo subirá hacia arriba y desaparecerá lo que hubiera en la primera línea.

Para aclarar la pantalla y no liarnos con lo anterior hemos puesto en todos los ejemplos CLS como primera instrucción 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 más detalle la instrucción PRINT que es la que usamos parara escribir en la pantalla.

Una aclaración. Si a alguien le parece que PRINT significa imprimir tiene razón, en informática a escribir en la pantalla del ordenador también se le puede llamar imprimir en pantalla. Además esta orden PRINT también se utiliza para imprimir como se verá más adelante.

La sintaxis de la instrucción 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$

En este caso se escribirá el valor de que tenga la variable, en nuestro ejemplo se escribiría Prueba Superada.

La variable también puede ser de tipo numérico...

PRINT total%

También podemos escribir el resultado de operaciones matemáticas...

PRINT 2+2

En este caso se escribirá 4. Las operaciones matemáticas (Expresiones) las veremos con detalle en el tema siguiente.

Después de escribir algo el cursor (invisible) pasa a la línea de abajo, por ejemplo

PRINT "Uno"

PRINT "Dos"

PRINT "Tres"

Escribiría...

Uno

Dos

Tres

Pero en algún caso nos puede interesar que no sea así y que se escriba lo siguiente a continuación en la misma línea. Para hacerlo no tenemos más que escribir un punto y coma al final de la instrucción sobre la que queremos seguir, por ejemplo:

PRINT "Uno";

PRINT "Dos";

PRINT "Tres"

PRINT "Cuatro"

Escribiría...

UnoDosTres

Cuatro

Normalmente en una instrucción PRINT se suelen escribir varias cosas, como vimos en el programa saludador que primero escribía la palabra Hola y después nuestro nombre que estaba almacenado en la variable nombre$. Para hacer esto no hay más que separar con punto y coma (;) las distintas "cosas" que queremos escribir, por ejemplo:

nombrePrograma = "Super Juego"

nombreUsuario = "KB"

PRINT "Hola "; nombreUsuario; ", bienvenido a "; nombrePrograma

Escribiría...

Hola KB, bienvenido a Super Juego

Observa que los espacios entre palabras hay que ponerlos en algún sitio dentro de las comillas, de lo contrario saldría 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 tendría que ser...

234

pero no, es

 2  3  4

QBasic escribe siempre los números con un espacio delante y otro detrás. Lo que ha escrito exactamente es: Espacio 2 Espacio Espacio 3 Espacio Espacio 4 Espacio, el último espacio no lo vemos pero también lo ha escrito.

Una consecuencia de esto será que los números por ahora nunca van a salir justo en la parte izquierda de la pantalla, sino una posición más adelante, por ejemplo...

PRINT "Prueba"

PRINT 25

PRINT 74

PRINT "Fin prueba"

Escribiría...

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 ampliación.

Una cosa que sí podemos hacer ya es usar lo que se llama "Posiciones de tabulación". Esto es que QBasic divide cada línea de la pantalla en posiciones que comienzan cada 14 caracteres, la primera en la posición 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 escribirán 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 escribiría en pantalla...

Uno        Dos        Tres

Cuatro     Cinco      Seis

Siete      Ocho       Nueve

Esto será muy útil en los listados que veremos más adelante. Por supuesto en una misma instrucción podemos separar unas cosas con comas y otras con puntos y comas, según haga falta.

Introducción a los operadores

En este tema vamos a ver como construir las expresiones matemáticas y lógicas necesarias para que nuestros programas sea capaces de hacer cálculos.

Una expresión sería lo equivalente a las fórmulas que escribimos en una hoja de cálculo (Excel), es decir una sucesión de números, operadores (signos más, menos, etc.) y nombres de variables, entre otras cosas, colocados en el orden correcto.

Operador de asignación

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$ usábamos directamente la instrucción INPUT que se encargaba de leer los datos del teclado y guardarlos directamente en la variable. Aquí no empleábamos el operador de asignación, pero después hemos hecho cosas como:

mensaje$ = "Prueba superada"

o al declarar las constantes hacíamos:

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 "Expresión" que hay a su derecha, por lo tanto ya podemos decir que el signo igual es el operador de asignación en el lenguaje Basic.

En el caso más sencillo:

total = 500

hacemos que en la variable total se almacene el número 500, perdiéndose el valor que tuviera anteriormente.

También 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 asignación más cien. Dicho de otra forma, si la variable valía 500 ahora le vamos a almacenar su valor de 500 más 100, con lo que al final de la asignación 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 expresión numérica o a una variable numérica le asignamos una cadena se producirá un Error de Tiempo de Ejecución y el programa se parará.

También hay que tener en cuenta que si a una variable de tipo entero le asignamos una expresión cuyo valor es con decimales, el número almacenado se redondeará, por ejemplo...

num% = 10 / 3

hará que num% valga 3 en vez de 3.3333, igual que

num% = 20 / 3

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 expresión a la derecha.

Las expresiones nunca van a ir solas. Siempre van en una asignación o en una estructura condicional que ya veremos más adelante.

Contadores y acumuladores

Estas dos palabras se usan mucho en programación para referirse a variables que van incrementando su valor a lo largo de la ejecución del programa.

Normalmente serán de tipo numérico 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

tamaño = tamaño * 2

Es muy importante inicializarlas de forma correcta siguiendo estas normas:

·         Si vamos a sumar o restar la inicializaremos a cero al principio del programa para que no empiecen con valores residuales.

·         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 número, como por ejemplo el total de una factura, mientras que los contadores se incrementan siempre con el mismo número, normalmente 1.

Operadores aritméticos

Llamamos operadores aritméticos a los signos que usaremos para hacer operaciones aritméticas como sumas, restas, etc.

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 división divide un valor entre otro, por ejemplo:

kilos = gramos / 1000

El operador MOD nos devuelve el resto de una divisíón. Es especialmente útil para deducir si un número es par, ya que al dividir un par entre 2 el resto siempre es 0. Se usa entre los dos operandos igual que los símbolos anteriores, veremos su funcionamiento y su utilización en los temas siguientes.

El operador "acento circunflejo" sirve para calcular potencias, por ejemplo 5^2 es cinco al cuadrado o también 5*5. También podríamos calcular potencias decimales como 4^2.5. Para escribir este símbolo pulsa mayúsculas y la tecla correspondiente dos veces, oirás un pitido y solo entonces aparecerá escrito en la pantalla. Si aparece dos veces borra uno.

Operadores relacionales o de comparación

Estos operadores hacen que una expresión devuelva un valor lógico, es decir, en vez de un número devolverá VERDADERO o FALSO. Esto nos será muy útil en las estructuras condicionales que veremos en los siguientes temas, dónde veremos muchos ejemplos de su utilización.

En QBasic el signo igual sirve tanto para asignaciones como para comparaciones, pero nunca se confunden ya que QBasic los evalúa de una u otra forma según dónde estén escritos.

Operadores lógicos

Estos operadores también devuelven un valor VERDADERO o FALSO a partir de los valores de las dos expresiones lógicas que unen. Igual que los anteriores se explicarán en los temas siguientes dedicados a estructuras condicionales.

Los tres primeros son las puertas lógicas elementales del álgebra de Boole, los otros se pueden construir a partir de las anteriores y por eso no suelen estar en otros lenguajes de programación y no hablaremos de ellos aquí.

AND devuelve verdadero si las dos expresiones que une son verdaderas, en caso contrario devuelve falso. Por ejemplo:

esNavidad = ((mes = 12) AND (dia = 25))

Podemos asegurar que es Navidad si el mes es 12 y el día es 25. Si el mes no es diciembre no será navidad aunque estemos a 25, tampoco si es un día de diciembre distinto de 25 y mucho menos si ni es diciembre ni es 25. Usamos por primera vez los paréntesis para dar más claridad, más adelante se explica cómo hacerlo.

OR devuelve verdadero si alguna de las dos expresiones que une es verdadera, o las dos lo son. Si las dos son falsas devuelve falso, por ejemplo:

puedesComprar = ((tuDinero > 0) OR (precio = 0))

En este caso la variable puedesComprar sería 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 sería falso si no tienes dinero y el producto a comprar vale dinero, con lo que las dos partes de la expresión serían falsas y el resultado también.

NOT es un operador "monario". Esto significa que sólo tiene un operando, a diferencia de los otros que siempre están entre dos operandos. Lo que hace NOT es invertir el resultado de una expresión, es decir, si es verdadera devuelve falso y si es falsa devuelve verdadero.

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

Observa que la variable puedesComprar y la esNavidad del ejemplo anterior pueden ser de cualquier tipo numérico para poder ser verdaderas o falsas. QBasic entiende que una variable (o el resultado de una expresión) es falsa si vale 0 y verdadera en cualquier otro caso. Otros lenguajes tienen un tipo de datos específico para estas situaciones, pero aquí puede valer cualquier tipo de datos numérico.

Es normal declarar constantes al principio de los programas para poder usar las palabras VERDADERO y FALSO en las expresiones y darle más claridad. Se haría:

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 lógico.

FUNCIONES INCLUIDAS EN EL LENGUAJE

El lenguaje BASIC incluye un montón de funciones que nos harán algunos cálculos sin necesidad de tener que programar nosotros todo lo necesario.

Una función es una palabra que, insertada dentro de una expresión, llama a un pequeño "programita" que hace los cálculos y nos devuelve un resultado. Veamos este ejemplo:

CLS

INPUT "Escribe un número: ", num

raiz = SQR(num)

PRINT "Su raíz cuadrada es ";raiz

Este programa nos pide que escribamos un número y lo guarda en la variable num. A continuación calcula la raíz cuadrada del número usando la función SQR y gualda el resultado en la variable raiz para al final escribirlo en pantalla. No hemos tenido que programar ni conocer las operaciones mátemáticas necesarias para calcular la raíz cuadrada de un número, lo ha hecho automáticamente la función.

Observa la forma de decirle a la función cual es el número que queremos que utilice para calcular la raíz cuadrada: Lo metemos entre paréntesis después del nombre de la función. Este número se dice que es un Parámetro que pasamos a la función. Si alguna función no necesita parámetros no ponemos nada, en otros lenguajes hay que poner los paréntesis vacíos detrás del nombre de la función, pero en QBasic no.

El parámetro no tiene por que ser un número constante, puede ser a su vez otra expresión.

En la instrucción PRINT podemos incluir cualquier expresión, por lo tanto en el ejemplo anterior nos podíamos haber ahorrado la variable raiz escribiendo directamente:

CLS

INPUT "Escribe un número: ", num

PRINT "Su raíz 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 identificación de tipo a continuación del nombre, por ejemplo la función TIMER nos devuelve el número de segundos que han pasado desde las doce de la noche en formato numérico:

segundos = TIMER

mientras que la función 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 parámetros porque si lo que hacemos es preguntar la hora no tenemos que decir nada más, ya la propia función verá como saca la hora del reloj interno del ordenador.

Si una función lleva varios parámetros se pondrán separados por comas dentro de los paréntesis, por ejemplo:

PRINT STRING$ (20,"Z")

La función 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 parámetros separados por una coma.

Observa también en el ejemplo que el primer parámetro debe de ser un número (o una expresión numérica) y el segundo tiene que ser una cadena (o una expresión de cadenas). Para saber de que tipo es cada parámetro y el tipo del resultado que devuelve la función es muy importante consultar la ayuda de QBasic todas las veces que haga falta. Si intentamos pasar parámetros de otro tipo se producirá un error de tipos y el programa se parará.

También se producirá un error de "Llamada a función no válida" si la función no es capaz de hacer los cálculos con los parámetros que le hemos pasado, aunque sean del tipo correcto. Por ejemplo, sabemos que no existe raíz cuadrada para los números menores que cero, por lo que se producirá un error de este tipo si hacemos

PRINT SQR (-14)

En caso de que pasemos como parámetro una expresión, por ejemplo

PRINT SQR(miVariable)

hay que tener mucho cuidado de que esta expresión no pueda llegar a valer menos que cero.

Estas son algunas de las funciones más usadas. En temas posteriores irán apareciendo más. Para verlas todas y todos los tipos de datos que necesitan y devuelven mira la ayuda del QBasic.

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 función INKEY$ que es especialmente útil para detectar teclas pulsadas en menús, juegos, preguntas que se responden con sí o no, etc.