|
Si se deseara imprimir los resultados de multiplicar un número fijo por otro que adopta valores entre 0 y 9, la forma normal de programar esto sería crear una constante para el primer número y un par de variables para el segundo y para el resultado del producto. Una variable no es más que un nombre para identificar una (o varias) posiciones de memoria donde el programa guarda los distintos valores de una misma entidad . En un programa BASIC es conveniente definir todas las variables que se utilizarán antes de comenzar a usarlas, a fin de indicarle al intérprete o compilador de que tipo serán y, por tanto, cuánta memoria debe destinar para albergar a cada una de ellas, aunque en QBasic no es obligatorio. Veamos un ejemplo:
' Multiplica dos números enteros DIM multiplicador AS INTEGER ' defino <multiplicador> como un entero DIM resultado AS INTEGER ' defino <resultado> como un entero multiplicador = 1000 ' asigno valores resultado = 2 * multiplicador PRINT "Resultado = ", resultado ' muestro el resultado END |
Así, una variable es un lugar donde se puede almacenar temporalmente un dato. En BASIC las variables tienen un nombre que las identifica, y sirve para hacer referencia a ellas. También tienen un tipo, que es el tipo de datos que puede almacenar. El valor de las variables es, como su propio nombre indica, variable. Podemos alterar su valor en cualquier punto del programa.
Para dar un nombre a una variable tenemos que usar un identificador. La longitud de un identificador puede variar entre uno y varios caracteres, por lo general, 40. En la mayoría de los casos el primer carácter debe ser una letra. A continuación se muestran varios ejemplos de nombres de identificadores correctos e incorrectos:
Correcto | Incorrecto |
cuenta | 1cuenta |
prueba23 | prueba* |
puerto.paralelo | puerto_paralelo |
El lenguaje QBasic no es sensible a mayúsculas y minúsculas (no es case sensitive), de modo que para el intérprete es lo mismo el identificador cuenta que otro denominado Cuenta.
Los intérpretes y compiladores reservan determinados términos ó palabras claves (keywords), para el uso sintáctico del lenguaje, tales como: CLS, PRINT, END, etc. y no se pueden utilizarla en nombres de variables.
Para crear una variable en un lugar determinado del un programa escribiremos primero el tipo de variable y luego el identificador con el que queremos nombrar la variable. A esto se le denomina definir una variable. La forma general de la definición es:
DIM identificador [AS tipo]
DIM identificador[sufijo]
Por ejemplo:
DIM numero AS INTEGER ' crea la variable numero, de tipo número entero
DIM numero% ' crea la variable numero, de tipo número entero DIM frase AS STRING ' crea la variable frase, de tipo cadena
DIM frase$ ' crea la variable frase, de tipo cadena
DIM a!, b# ' crea dos variables a y b, de tipo número de precisión simple y doble, respect.
DIM a AS SINGLE, b AS DOUBLE ' crea dos variables a y b, ...
En QBasic, las variables no se pueden inicializar (es decir, establecer un valor inicial) en el momento de creación. Por ejemplo, es incorrecto:
DIM numero% = 0 ' incorrecto, falla el intérprete
DIM frase$ = "Hola" ' incorrecto, falla el intérprete
La asignación de valores a las variables hay que realizarla posteriormente a la definición de las mismas.
En QBasic, se pueden definir variables en cualquier parte de un programa.
Los tipos de datos atómicos definidos por QBasic son:
Tipo | Sufijo | Tamaño | Intervalo | Descripción |
---|---|---|---|---|
STRING |
$ |
conjunto de caracteres (de 8 bits) | 0 a 32 767 caracteres | Las variables string son las que almacenan texto. Ejemplos: "¿Qué estás haciendo?", "Alpha Sigma Pi", "323" (esto no es un número porque se delimita con comillas). |
INTEGER |
% |
16 bits | -32 768 a 32 767 | Las variables enteras almacenan números enteros (sin
parte decimal). Ejemplos: 4323, 1, -7543, 30000 (no se utilizan separadores de millares). |
LONG |
& |
32 bits | -2 147 483 648 a 2 147 483 647 | Almacenan también enteros. Ejemplos: 54500, 0, 123456789. |
SINGLE |
! |
32 bits | 3.4 E-38
a 3.4E+38 (aprox. 6 dígitos de precisión) |
Las variables de precisión simple almacenan números de
coma flotante con 6 dígitos de precisión. Ejemplos: 123.456, 12300000000000, .0000000000000008. |
DOUBLE |
# |
64 bits | 1.7 E-308
a 1.7 E+308 (aprox. 12 dígitos de precisión) |
Las variables de precisión doble almacenan números de
coma flotante con 12 dígitos de precisión. Ejemplos: 10000000000000000000000000000000000000000000, .000000000000000400005. |
Veamos el siguiente programa de ejemplo acerca del uso de variables:
' Convierte grados Centígrados a Fahrenheit DIM cels!, fahr! cels = 25 ' Temperatura en º C fahr = 32 + 9 * fahr / 5 ' Temperatura en º Fahrenheit PRINT ">>> ";cels;" ºC son ";fahr;" ºF END |
En él se definen dos variables single, se asigna un valor a la primera y se calcula la segunda mediante una expresión aritmética. En la instrucción PRINT, el ; indica que se concatenen los valores a mostrar.
En Qbasic no es obligatorio definir el tipo de datos de una variable antes de utilizarla, aunque si es conveniente. De hecho, el programa anterior también funciona así:
' Convierte grados Centígrados a Fahrenheit cels = 25 ' Temperatura en º C fahr = 32 + 9 * fahr / 5 ' Temperatura en º Fahrenheit PRINT ">>> ";cels;" ºC son ";fahr;" ºF END |
En este caso es el intérprete el que asigna automáticamente el tipo de los datos a las variables. Esto facilita bastante la tarea de programar, sobre todo a usuarios inexpertos, aunque no es lo más eficiente.
La sentencia LET asigna un valor a una variable. La sintaxis de uso es:
expresión es una expresión del mismo tipo que la variable - número o string -. No se puede poner un valor string en una variable numérica y viceversa. La palabra clave LET es opcional. En la mayor parte de los usos se prescinde de LET y de deja sólo variable = expresión (es más claro y sencillo). Si se intenta poner un valor decimal en una variable entera el valor se redondea. Se pueden poner valores enteros en variables Single y Double.
Ejemplos:
LET micadena$ = "Esto es una prueba."
LET resultado% = var1% + var2% - var3%
mezcla# = i% + l& + s! + d#
Otra característica de las variables es su alcance. El alcance se refiere a los lugares de un programa en los que podemos utilizar una determinada variable. Distinguiremos así dos tipos principales de variables:
Una variable es global cuando es accesible desde todo el programa, y es local cuando solo puede acceder a ella la función que la creó.
Variable Global | Variable Local |
' Muestra un número entero DIM SHARED x1% x1% = 100 Muestra END SUB Muestra PRINT x1% END SUB |
' Muestra un número entero DIM x2% x2% = 100 Muestra END SUB Muestra PRINT x2% END SUB |
En el primer caso el resultado que se obtiene al ejecutar el programa es:
100
mientras que en el segundo es:
0
La palabra clave SHARED consigue que la variable x1 sea global, es decir, accesible en todo el código (todos los subprogramas) del módulo. Por el contrario, x2 es local y sólo se conserva su valor en el programa principal, no siendo accesible desde los subprogramas.
Otro ejemplo:
Variable Global | Variable Local |
' Muestra un número entero Valor PRINT x1% END SUB Valor SHARED x1% ' Aquí sólo se escribe SHARED, ' no DIM SHARED x1% = 100 END SUB |
' Muestra un número entero Valor PRINT x2% END SUB Valor DIM x2% PRINT x2% END SUB |
De nuevo, el resultado que se obtiene al ejecutar el programa es en el primer caso:
100
mientras que en el segundo:
0