Académique Documents
Professionnel Documents
Culture Documents
Introducción
sistema de TRAducción de
1956 FORTRAN IBM
FORmulas matemáticas
1956 COBOL Compilador
1958 ALGOL 58
Intérprete orientado a la Inteligencia
1960 LISP
Artificial
sistema de TRAducción de
1961 FORTRAN IV IBM
FORmulas matemáticas
1961 COBOL 61 Extendido
1960 ALGOL 60 Revisado
1964 PASCAL Niklaus Wirth programación estructurada
Universidad de
Beginners All Purpose Symbolic
1964 BASIC Dartmouth
Instruction Code
(california)
1965 SNOBOL
1965 APL sólo anotación
1965 COBOL 65
1966 PL/I
sistema de TRAducción de
1966 FORTRAN 66 IBM
FORmulas matemáticas
1967 SIMULA 67
1968 ALGOL 68
1968 SNOBOL4
1970s GW-BASIC antiguo y clásico BASIC
1970 APL/360
Centro de
1972 SMALLTALK Investigación de pequeño y rapido
Xerox en Palo Alto
1972 C Laboratorios Bell lenguaje con tipos
1974 COBOL 74
1975 PL /I Lenguaje sencillo
sistema de TRAducción de
1977 FORTRAN 77 IBM
FORmulas matemáticas
1980s SMALLTALK/V Digitalk pequeño y rapido
1980 C con clases Laboratorios Bell lenguaje con clases
Ministerio Japonés
de Comercio Lenguaje estandar para la
1981 PROLOG
Internacional e Inteligencia Artificial
Industria (MITI)
Ministerio de
1982 ADA Defensa de los lenguaje muy seguro
EE.UU
AT&T Bell
1984 C++ Laboratories (Bjarne compilador
Stroustrup)
1985 CLIPPER compilador para bases de datos
1985 QuickBASIC 1.0 Microsoft® compilador de BASIC
1986 QuickBASIC 2.0 Microsoft® soporte de tarjeta gráfica EGA
1987 QuickBASIC 3.0 Microsoft® 43 lineas con la tarjeta EGA
1987 QuickBASIC 4.0 Microsoft® tarjetas Hercules, VGA
1987 CLIPPER SUMMER '87 compilador para bases de datos
1988 QuickBASIC 4.5 Microsoft® tarjeta SVGA
1989 QuickBASIC 7.1 Microsoft® ultima version de QuickBASIC
1989 ASIC v5.0 interprete tipo QBASIC shareware
1990s VISUAL C++
1990s VISUAL BASICScript Microsoft® lenguaje de script
1990 HTML Tim Berners-Lee para internet
para MS-DOS 5.0. Compatible 99.9%
1991 QBasic 1.0 Microsoft®
con QuickBasic
C. M. Sperberg-
1993 XML para internet
McQueen
1993 SGML Charles F. Goldfarb para internet
1993 QBasic 1.1 Microsoft® para MS-DOS 6.0
1990s WML para internet
1990s ASP Microsoft® para internet
1990s PHP para internet
1995 JAVA Sun Microsystems para internet y proposito general
1995 CLIPPER 5.01 compilador para bases de datos
Ministerio de
1995 GNAT ADA95 Defensa de los lenguaje muy seguro
EE.UU
sistema de TRAducción de
1995 FORTRAN 95 IBM
FORmulas matemáticas
1991 VISUAL BASIC 1.0 Microsoft®
1992 VISUAL BASIC 2.0 Microsoft®
los archivos fuente se guardaban en u n formato de texto regular, legibles por otros
programas
la interfaz de programación era ligeramente más amigable
GW-Basic no era todavía demasiado adecuado para un uso masivo, de modo que Microsoft
en 1987 crea una actualización de Basic denominada Quic kBasic, con las siguientes
ventajas:
La mejor forma de aprender un lenguaje es programando con él. El programa más sencillo
que se puede escribir en BASIC es el siguie nte:
Como podemos imaginar, este programa sin una sola instrucción no hace nada, pero se
interpreta correctamente y nos da una idea de que no se necesita mucho para empezar a
programar en BASIC. Esto no es cierto en otros lenguajes como C, en los que ha y que
utilizar obligatoriamente encabezados de programa y limitadores de bloques de sentencias.
CLS
PRINT "Bienvenido a la programación en lenguaj e BASIC"
END
CLS
Esta línea constituye una sentencia. La sentencia consta únicamente de la instrucción CLS ,
y ésta produce el resultado de borrar la pantalla.
La siguiente sentencia incluye la instrucción PRINT. Ésta toma como argumento una cadena
de caracteres limitados por dobles comillas " " y la imprime en la salida habitual, que
generalmente es la pantalla del PC en el que trabajamos.
Elemento Definición
Sentencia Es una instrucción que realiza una operación. Se utilizan estas
Instrucción palabras de forma intercambiable. Se usa mucho la forma comando
(Comando) debido a su utilización en inglés.
Una palabra que forma parte del lenguaje QBasic. Cuando se utiliza
Palabra clave una palabra clave en una sentencia, QBasic automáticamente la
Keyword convierte a mayúsculas. No se puede utilizar una palabra clave para
dar nombre a una constante o variable (palabra reservada).
Cadena Una cadena de texto (caracteres). En Qbasic se delimita con
String comillas, por ejemplo, "Bienvenido". La cadena "" (vacía) es válida.
Designa a números enteros, decimales de precisión simple y
Número
decimales de precisión doble.
Un valor (cadena o número) que no cambia a lo largo de la ejecución
del programa. Hay dos clases de constantes; las constantes literales
están escritas directamente en el código: "Hola", 16; las constantes
Constante
simbólicas o con nombre son valores constantes a los que se les
asigna un nombre. Por ejemplo, LONG_MAX en lugar de 16. Las
constantes simbólicas se definen usando la palabra clave CONST.
Un contenedor con nombre para un número o una cadena. Son el
medio para que el programa "recuerde" datos. Se pueden crear
Variable
variables de varias maneras: calculando un valor, tomando una
entrada de usuario, leyendo un archivo, etc.
Designa una operación matemática. Los operadores pueden ser
Operador
aritméticos, relacionales o lógicos.
Devuelve una cadena o un número. Puede tomar uno o más
Función
parámetros de entrada para calcular el result ado.
No hace nada en el programa. Se utiliza como una nota explicativa
Comentario que contribuye a clarificar el código y a recordar más tarde lo que se
hizo.
Designa a un conjunto de líneas dentro de la estructura del programa,
Bloque
que guardan una relación de algún tipo entre sí.
Bucle Designa a un grupo de líneas que se ejecutan una serie de veces.
END SUB
FUNCTION Funcion1 ( )
declaración de variables
sentencias
END FUNCTION
...
...
...
SUB Subprograman( )
declaración de variables
sentencias
END SUB
FUNCTION Funcionn ( )
declaración de variables
sentencias
END FUNCTION
Introducción
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 d efinir 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:
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.
Correcto Incorrecto
cuenta 1cuenta
prueba23 prueba*
puerto.paralelo puerto_paralelo
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:
Por ejemplo:
DIM frase AS STRING ' crea la variable frase, de tipo cad ena
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 inic ializar (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
cadenas de caracteres
números enteros
números en coma flotante
END
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 instrucción LET
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:
globales
locales
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ó.
Muestra Muestra
END END
SUB Muestra SUB Muestra
PRINT x1% PRINT x2%
END SUB END SUB
100
La palabra clave SHARED consigue que la variable x1 sea global, es decir, a ccesible 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:
100
Unas de las principales vías de comunicación de un programa con el usuario son la pantalla
(terminal) y el teclado. La entrada y salida de datos por estos medios se pueden realizar
mediante varias instrucciones de QBasic. Las fundamental es son:
PRINT
INPUT
y algunas más avanzadas:
PRINT USING
LINE INPUT
LOCATE
CLS
La función PRINT escribe texto y/o números en la pantalla (aunque también en un archivo).
Su uso en sencillo, sólo hay que añadir detrás de la palabra clave la lista de datos que se
desea visualizar. Por ejemplo:
PRINT "Hola"
PRINT "mundo"
END
El resultado es:
Hola
mundo
Nótese que PRINT imprime un sal to de línea tras el texto. Se puede inhibir el salto
automático de línea si se añade ; tras el texto:
PRINT "Hola";
PRINT "mundo"
END
Hola mundo
a% = 50
b% = 100
END
cuyo resultado es:
Nótese que al concatenar el texto con los números mediante ; se añade automáticamente un
espacio en blanco antes de cada valor numérico.
a% = 50
b% = 100
END
el resultado es:
Algo muy usual en un programa es esperar que el usuario introduzca datos por el teclado.
Para ello contamos con la i nstrucción INPUT. Un ejemplo:
Introduce un número? 23
Has tecleado el número 23
De esta forma, cuando el usuario ejecuta el programa debe introducir los tres datos
separados por una coma y finalizar con un retorno de carro.
Es muy común escribir un mensaje con PRINT antes de realizar un INPUT, como en los
dos ejemplos anteriores. Pero INPUT facilita la labor si se utiliza así:
Introduce un número: 23
Has tecleado el número 23
Esta instrucción es similar a PRINT pero es capaz de dar un formato especificado de salida
a los datos. La sintaxis de uso es:
donde formato es una cadena de texto que contiene distintos especificadores que aplican
formato a la lista_de_expresiones . Esta lista no es más que un conjunto de expresiones
numéricas o de texto concatenadas con ; o ,.
PRINT
PRINT "Producto Cantidad Importe Importe Total"
PRINT "-------- -------- --------- -------------"
LINE INPUT
Esta instrucción es sumamente similar a INPUT, si bien almacena en una sola variable toda
la entrada proporcionada desde teclado hasta encontrar un retorno de carro y no considera
las comas (,) separadores de variables (como sucedía con INPUT).
Por ejemplo:
Hemos visto que cuando usamos PRINT se escribe en la posición actual del cursor y se
mueve éste al final de la cadena que hemos escrito. Pero ¿qué sucede cuando queremos
escribir en una posición determinada de la pantalla?. La solución está en la función LOCATE.
Supongamos que queremos escribir 'Hola' en la fila 20, columna 10 de la pantalla:
LOCATE 20, 10
PRINT "Hola"
END
Obsérvese que primero se indica la fila (y) y luego la columna (x). La esquina superior
izquierda es la posición (1, 1).
CLS
Ahora ya sólo resta saber cómo se limpia la pantalla. Ello es tan fácil como usar:
CLS
Esta función no sólo borra la pantalla, sino que sitúa el cursor en la posición (1, 1), en la
esquina superior izquierda.
CLS
PRINT "Hola"
END
Subprogramas y Funciones
Introducción
Los subprogramas y las funciones admiten parámetros (argumentos), que son datos que le
pasan al procedimiento las sentencias que la llaman.
donde:
hola
END
PRINT "Hola"
END SUB
que simplemente es una función que cuando es llamada imprime en pantalla un mensaje de
saludo.
Cuando el programa al ejecutarse alcanza el cierre del procedimiento ( END SUB ), éste
finaliza y devuelve el control al punto del programa que lo llamó.
nombre_de_la_función = expresión
bloque_de_código
END FUNCTION
donde:
' Función que suma dos enteros y devuelve la suma como otro entero
FUNCTION Suma% (s1%, s2%)
END FUNCTION
Cuando el programa al ejecutarse alcanza el cierre del procedimiento ( END FUNCTION ), éste
finaliza y devuelve un valor de tipo entero al programa que lo llamó.
Retorno de valores
Cuando la función finaliza hemos dicho que se devuelve un valor. Para obligar a la función
a retornar un determinado valor se utiliza la sentencia
nombre_de_la_función = expresión
FUNCTION lista%
lista% = 1
END FUNCTION
devuelve el entero 1 cada vez que es llamada. En QBasic podemos devolver cualquier tipo
de datos de los llamados escalares. Los tipos de datos escalares son los tipos numéricos y el
tipo string. En QBASIC no se pueden devolver vectores ( array).
Utilizando la lista de argumentos podemos pasar parámetros a una función. En esta lista se
suele colocar un conjunto de identificadores, separados por comas, que representan cada
uno de ellos a uno de los parámetros de la función. Obsérvese que el orden de los
parámetros es importante. Para llamar a la función habrá que colocar los parámetros en el
orden en que la función los espera.
Cada parámetro puede tener un tipo diferente. Para declarar el tipo de los parámetros
añadiremos su tipo tras el identificador. Así:
END SUB
es una función que admite dos variables, una entera y otra de tipo cadena.
En los lenguajes de programación estructurada hay dos formas de pasar variables a una
función:
por referencia, o
por valor
Cuando la variable se pasa por referencia, la función puede acceder a la variable original.
Este enfoque es habitual en lenguajes como el BASIC. (En C, sin embargo, todos los
parámetros se pasan por valor. La función recibe una copia de los pa rámetros y variables, y
no puede acceder a las variables originales. Cualquier modificación que efectuemos sobre
un parámetro no se refleja en la variable original. Esto hace que no podamos alterar el
valor de la variable por equivocación.)
CLS
PRINT n%
imprime n%, l$
PRINT n%
END
numero% = 2
END SUB
da como resultado:
1
2 A
2
La lista de parámetros con tipo difiere de la lista de argumen tos antes presentada en que el
tipo de cada argumento se coloca dentro de la lista, tras de su correspondiente identificador,
como hacíamos en la definición de variables. Por ejemplo:
declara una función que devuelve un carácter y tiene dos parámetros, un entero y un
carácter.
NOTA:
DECLARE es requerido si se hace una llamada a un procedimiento FUNCTION o a uno SUB sin
CALL (véanse los ejemplos). QBasic generara automáticamente instrucciones DECLARE
cuando se guarda un programa.
La lista de argumentos permite al intérprete/compilador hacer comprobación de tipos, ya
que el tipo y numero de argumentos debe coincidir en la declaración, definición y llamada a
una función.
' Ejemplo
DIM caracter AS STRING
CLS
imprime$ = letra
END FUNCTION
Ejemplos
Subprograma sin argumentos (no devuelve nada)
Este programa llama a la función BorraPantalla que despeja la pantalla mediante la orden
CLS (clear screen) y muestra el mensaje "la pantalla está limpia". Por supuesto, es de nula
utilidad pero sirve para empezar.
SUB BorraPantalla
CLS
PRINT "La pantalla está limpia"
END SUB
En este ejemplo la función compara toma dos números, los compara y nos dice cuál es
mayor.
IF a > b THEN
PRINT a; " es mayor que "; b
ELSE
PRINT b; " es mayor que "; a
END IF
END SUB
Este ejemplo es como el anterior pero devuelve como resultado el mayor de los dos
números.
END
IF a > b THEN
compara% = a
ELSE
compara% = b
END IF
END FUNCTION
De esta forma nos hubiésemos ahorrado tener que definir la variable resultado .
Control de flujo
Introducción
En Qbasic las sentencias se ejecutan sucesivamente una tras otra (secuencialmente). Esto
define un camino o dirección según la cual se va desarrollado el programa. Sin embargo,
habrá momentos en que el programa deba ejecutar determinadas partes dependiendo del
estado en el que se halle el propio programa o las variables externas. Esto permitir
modificar el orden de la ejecución para adaptarse al estado del programa y bifurcar hacia
nuevas subrutinas cuando se cumplan ciertas condiciones, que el programador fija de
antemano. Los mecanismos en QBasic que permiten llevar esto a cabo son:
La instrucción IF
o también:
IF expresión THEN
[bloque_sentencias_1]
[ELSEIF expresion_2 THEN
[bloque_sentencias_2]]...
ELSE
[bloque_sentencias_n]
END IF
En este caso, si la variable num es menor o igual que cero el programa no mostrará ningún
mensaje, y en caso contrario se mostrará el mensaje correspondiente a la comparación del
valor con la unidad.
El bucle WHILE
WHILE expresión
bloque_sentencias
WEND
variable% = 10
variable% = variable% -1
WEND
En este caso se imprime el valor de la variable hasta que se llega a 1. Normalmente, en las
sentencias del bucle WHILE se coloca alguna instrucción que modifique la expresión de
control, como vemos en el ejemplo anterior.
El bucle DO - WHILE
o también:
DO
bloque_sentencias
LOOP [{WHILE | UNTIL} expresión]
Por ejemplo:
n% = 9
DO
PRINT "número actual "; n%
n% = n% -1
LOOP WHILE n% >= 0
este programa muestra el valor de n hasta que vale 0. Y el siguiente produce el mismo
resultado.
n% = 9
DO
PRINT "número actual "; n%
n% = n% -1
LOOP UNTIL n% = -1
El bucle FOR
FOR i% = 0 TO 10
PRINT "i vale "; i%
NEXT i%
Esta versión del bucle imprime el valor de i desde 0 con un incremento de una unidad
mientras que esta variable no alcance el valor 10.
FOR i% = 1 TO 10 STEP 2
PRINT "i vale "; i%
NEXT
contador = inicio
WHILE contador <= fin
bloque_sentencias
contador = contador + incremento
WEND
Este bucle WHILE puede servirnos para salir fácilmente de dudas al escribir un bucle FOR, ya
que se ve claramente el orden de ejecución de las expresiones y sentencias dentro del bucle
FOR. Como se ve, en cada pasada del bucle FOR se sigue el orden: evaluación del valor del
contador , ejecución de bloque_sentencias y e incremento del contador .
Hay veces en que interesa romper un bucle en una determinada posición, para finalizar su
ejecución. Esto suele ser habitual cuando el bucle tiene una gran complicación o cuando
necesitamos salir "por las malas" de él. Esto último suele ser frecuente cuando en el bucle
se producen "condiciones de error". Para este tipo de salto disponemos de la sentencia
EXIT.
Su sintaxis es:
a% = 10
DO WHILE 1
PRINT a%
IF a% <= 1 THEN EXIT DO
a% = a% -1
LOOP
Aunque en apariencia este es un bucle sin fin, ya que la condición WHILE 1 es siempre
cierta, este bucle se acaba cuando la variable a valga 1. El bucle simplemente imprime su
valor y decrementa la variable.
Otro ejemplo:
FOR i% = 1 TO 10
PRINT i%
INPUT a$
IF a$ = "S" THEN EXIT FOR
NEXT
el cual imprime enteros entre 1 y 10 h asta que se introduce por teclado la la pulsación S.
EXIT también se utiliza con procedimientos SUB o FUNCTION , para abandonar el
procedimiento antes de ejecutar todas las sentencias que preceden al correspondiente END
{SUB | FUNCTION}.
Esta sentencia sirve para agrupar varias sentencias IF en una sola, en el caso particular en
el que una variable es comparada a diferentes valores, todos ellos constantes, y que realiza
acciones si coincide con ellos. Su sint axis es:
Su sintaxis es más complicada que la de anteriores bucles, ya que agrupa un mayor número
de acciones y posibilidades en una sola sentencia. El modo de funcionamiento es el
siguiente:
Vamos a ver un ejemplo de múltiples casos con IF y luego con SELECT CASE :
IF num = 1 THEN
PRINT "Es un 1"
ELSEIF num = 2 THEN
PRINT "Es un 2"
ELSEIF num = 3 THEN
PRINT "Es un 3"
ELSE
PRINT "No es ni 1, ni 2, ni 3"
END IF
END
Introducción
"Un conjunto de datos del mismo tipo, identificados por el mismo nombre, y que se pueden
distinguir mediante un núm ero de índice."
Pero ¿qué quiere decir esto y para qué lo queremos?. Pues bien, supongamos que queremos
almacenar la temperatura media de cada hora del día y la temperatura promedio del día.
Con lo que sabemos hasta ahora podríamos hacer algo así:
Los puntos ... se utilizan por brevedad en el ejemplo; no constituyen una expresión válida en QBasic .
Observamos que hay que realizar un notable trabajo repetitivo de escritura de código.
Precisamente es aquí donde son de utilidad lo s arrays. Vamos a repetir el programa anterior
con un array:
El programa resulta más rápido de escribir y más cómodo para el usuario que el anterior.
Como ya hemos comentado, cuando decl aramos una variable lo que estamos haciendo es
reservar una zona de la memoria para ella. Cuando declaramos el array de este ejemplo
reservamos espacio en memoria para 24 variables de tipo SINGLE. El tamaño del array (24)
lo indicamos entre paréntesis al d efinirlo. Esta es la parte de la definición que dice: Un
array es un conjunto de datos del mismo tipo identificados por el mismo nombre .
En el ejemplo anterior el primer elemento de una matriz tiene el índice 0, el segundo tiene
el 1, y así sucesivamente. De modo que si queremos dar un valor al elemento 4 (índice 3)
haremos:
temp!(3) = 20
donde:
dimensión también se puede especificar dando los límites superior e inferior de los
subíndices del array:
Inicialización de un array
En QBasic se inicializan los arrays al asignar valores a cada elemento de los mismos. Es
decir, por ejemplo:
temp!(9) = 20
temp!(12) = 25
temp!(20) = 23
Ahora el elemento 10, es decir, temp!(9) , valdrá 20. El elemento 13 valdrá 25, y el
elemento 21 valdrá 23. El resto, si no se asignan, tomarán valor 0 por defecto. Por ejemplo,
el programa:
temp!(9) = 20
temp!(12) = 25
temp!(20) = 23
FOR hora% = 0 TO 23
PRINT "La temperatura a las";hora%;" era de";
temp!(hora%);"grados."
NEXT hora%
Vemos que los elementos a los que no se ha asignado valor inici al son nulos
En las secciones anteriores veíamos ejemplos de matrices con una sola dimensión (un sólo
índice o subíndice). Pero las matrices pueden contar con más dimensiones. La utilización
de matrices multidimensionales no es más que la extensión natural de la correspondiente a
unidimensionales.
DIM matriz(dimension1,dimension2)
o también:
Y para acceder al elemento caracterizado por los subíndices i,j de la matriz no hay más
que escribir la expresión matriz(i,j).
En QBasic podemos pasar un array entero a una función. Lo que tenemos que hacer es
poner como argumento de la función el identificador del array seguido de () para que se
reconozca como tal. Considérese este ejemplo:
FOR contador% = 1 TO 10
matriz(contador%) = 2*contador% ' Asigna
valores a los elementos
PRINT contador%, matriz(contador%)
NEXT contador%
PRINT "La suma es "; sumar(matriz())
END
suma% = 0
FOR i% = 0 TO 10
suma% = suma% + m(i%)
NEXT i%
sumar = suma%
END
Este programa muestra los 10 elementos de un array y halla su suma. Obsérvese que en el
argumento de la función sumar se especifica el array pero sin dimensiones, para que tome
la dimensión del array utilizado en la llamada al procedimiento en el programa principal.
Manejo de archivos
Los archivos o ficheros brindan una forma de guardar permanentemente los datos y
resultados de nuestros programas.
Es importante indicar que los ficheros no son únicamente los archivos que guardamos en el
disco duro. En QBasic algunos dispositivos del ordenador (como e l puerto serie de
comunicaciones) se tratan como ficheros.
Para comenzar, vamos a analizar un ejemplo que lee un fichero de texto ( origen.txt ) y
muestra su contenido en la pantalla:
Ahora es preciso abrir el fichero. Para ello usamos la función OPEN. Esta sentencia tiene el
siguiente formato:
En el ejemplo usábamos:
INPUT
especifica que el archivo va a ser abierto para leer información
de forma secuencial.
OUTPUT
especifica que el archivo va a ser abierto para escribir inform ación de
forma secuencial.
especifica que el archivo va a ser abierto en el modo de acceso
RANDOM
aleatorio. RANDOM es el modo de archivo predeterminado.
especifica que el archivo va a ser abierto para añadir información de
APPEND salida secuencial y coloca el puntero de archivo al final del archivo. Una
instrucción PRINT # o WRITE # añade la información al archivo.
especifica el modo de archivo binario. En este modo, es posible
BINARY leer o escribir información en cualquier posición de byte del archi vo
usando instrucciones GET o PUT.
nº_archivo es un identificador que permite distinguir los distintos ficheros que se utilizan,
cuando se usan varios simultáneamente.
Ahora ya podemos empezar a leer el fichero. Para ello podemos utilizar la función LINE
NPUT # , que lee las líneas de texto del archivo de una en una. Se puede usar tambié n la
función INPUT # que lee texto del archivo hasta que encuentra una coma (,).
El formato de la instrucción INPUT # es:
donde linea es una variable string. Tomamos una línea de fichero , la almacenamos en
linea y el puntero del fichero se coloca al principio de la línea siguiente.
Cuando entramos en el bucle WHILE, la lectura se realiza hasta que se encuentre el final del
fichero. La detección del final del fichero se puede llevar a cabo con la función EOF().
EOF(nº_archivo)
DO UNTIL EOF(1)
Una vez realizadas todas las operaciones deseadas sobre el fichero hay que cerrarlo. Es
importante no olvidar este paso pues el fichero podría corromperse. Al cerrarlo se vacían
los buffers y se guarda el fichero en disco. Un fichero se cierra mediante la instrucció n
CLOSE . Esta función tiene el siguiente formato:
CLOSE [#]nº_archivo
CLOSE #1
Esta función es muy útil para leer caracteres un nº de caracteres determinado del archivo.
Su formato es:
INPUT(nº_caracteres, [#]nº_archivo)
Esta función lee desde el fichero nº_archivo el número de bytes especificado por
nº_caracteres.
Vamos a completar ahora la parte que faltaba en la sección anterior: escribir en un fichero.
Vamos a hacerlo de nuevo mediante un eje mplo. En éste, abrimos un fichero origen.txt
y lo copiamos en otro destino.txt . Además, el fichero se muestra en pantalla (las partes
nuevas se han destacado en negrita).
CLOSE #1, #2
END
El siguiente paso, como antes, es abrir el fichero usando OPEN. La diferencia es que ahora
tenemos que abrirlo en modo escritura. Usamos el modo OUTPUT (crea el fichero, o lo vacía
si existe) porque queremos crear un fichero:
Como se puede observar en el ejemplo, la lectura del fichero se hace igual que antes, con
LINE INPUT # . Para la escritura usamos la función PRINT , cuya sintaxis es:
(nótese el ; final) en el archivo destino.txt las líneas del archivo origen apare cerían
concatenadas (es decir, no se producirían saltos de línea)
Como siempre que leemos datos de un f ichero debemos comprobar si hemos llegado al
final. Sólo debemos comprobar si estamos al final del fichero que leemos. No tenemos que
comprobar el final del fichero en el que escribimos puesto que lo estamos creando y aún no
tiene final.
Y, por fin, lo que nunca debemos olvidar al trabajar con ficheros: cerrarlos. Debemos cerrar
tanto los ficheros que leemos como aquellos sobre los que escribimos.
CLOSE #1, #2
WRITE
Sin embargo, WRITE inserta comas (,) entre los datos y comillas (") alrededor de cadenas de
texto. Para notar la diferencia considérese el sig uiente ejemplo:
CLOSE #1
1 2 Tecnología
1,2,"Tecnología"
GET y PUT
La sintaxis es:
GET [#]numarchivo%[,[numregistro&][,variable]]
PUT [#]numarchivo%[,[numregistro&][,variable]]
Por ejemplo:
LOC(nº_archivo%)
La instrucción SEEK establece la posición del archivo para la siguiente acción de lectura o
escritura:
FOR i% = 1 TO 10
PUT #1, , i%
NEXT i%
Este programa escribe secuencialmente 10 registros con los enteros entre 1 y 10, se
posiciona en el segundo registro y lo lee; proporciona la salida :
Introducción
Para intercambiar información con dispositivos exteriores, el computador utiliza los puertos
de entrada y salida (E/S). Estos p uertos se caracterizan por la dirección que tienen asignada
en el mapa de memoria, y es posible la comunicación con los mismos enviando o
recogiendo bytes a/en dicha dirección. Así, nos centraremos ahora en las funciones de
acceso a los puertos hardware que proporciona Qbasic.
Para recoger información procedente de un puerto hardware (lectura del puerto), Qbasic
proporciona la funciñon INP. Esta función devuelve un byte leído del puerto ( hardware) de
E/S.
valor% = INP(puerto_dir)
donde:
valor = INP(puerto)
PRINT "El byte leído del puerto "; puerto; " es "; va lor
END
Escritura en el puerto
donde:
Acceso a la memoria
Lectura de la memoria
valor% = PEEK(dirección%)
donde:
NOTA: DEF SEG establece el segmento de memoria sobre el que se realizará la operación
de lectura (un valor entre 0 y 65.535). Por ejemplo DEF SEG = 0 .
Como ejemplo, veamos cómo se determina cuántos puertos paralelo se hallan instalados en
un PC, y qué direcciones de E/S tienen asignadas. Para ello, es preciso leer en la posición
de memoria 408h una tabla de 3 palabras de 16 bits (2 bytes) que contienen las direcciones
de los puertos paralelo presentes en el sistema:
NEXT puerto%
END
Escritura en la memoria
donde:
Como ejemplo, veamos cómo se fuerza por software la activación de "Bloq Mayús". Para
ello hay que cambiar el bit 6 de la posición 417h, lugar de las variables de la BIOS donde
residen los banderines de estado del teclado:
Estilo de programación
Trataremos de dar unas breves indicaciones acerca de cuál es la forma más correcta de
programar. Qué aspecto dar al código fuente para que sea más legible y elegante, cómo
distribuir el código fuente, etc
Parece claro que la segunda es más conveniente. Desde luego no es la única forma, ni la
más correcta; es, simplemente, un estilo. Cada uno tiene su esti lo personal, aunque
conviene que tampoco sea 'muy personal', si es para compartirlo. El tabular la escritura del
código lo hace más legible y fácil de mantener.
Los comentarios
El código fuente debe estar bien documentado, de tal forma que si se lo pa samos a otra
persona pueda entenderlo sin grandes dificultades. Quizá se piense: "mi código es mío y
nunca se lo voy a dejar a nadie, así que para que voy a comentarlo". Parece lógico, pero
imagínese que se abandona temporalmente y en el futuro se quiere r etocar el programa. Es
muy probable el olvido de por qué se hizo tal o cual cosa, (pasa muy a menudo) y es
preciso gastar un montón de tiempo descifrando algo que en su día estaba entendido
perfectamente.
Estos comentarios están bien si el código forma parte de algún curso, pero no de un
programa de uso habitual. Todo el mundo (q ue lleva un poco de tiempo programando en
BASIC) sabe que con FOR se realiza un bucle repetitivo y que con END se finaliza el
programa.
Los comentarios deben decirnos qué es lo que hace el programa, para qué sirven las
variables y explicar las partes críti cas o confusas del programas. Algo mas correcto sería:
' EJEMPLO.BAS
' Programa ejemplo creado para el curso de BASIC (QBasic 1.1)
' Víctor R. González, 2/02/2002
END
Este programa es tan sencillo que no tiene puntos oscuros para comentar.
Es importante indicar para qué se van a usar las variables. Cuando tengamos muchas y pase
el tiempo es difícil descifrar para que era cada una.
Los nombres de las variables
Cuando hacemos un programa con prisas o por no pensar mucho damos a las variables
cualquier nombre. Supongamos un programa con una sección de declaración de variables
como la que sigue:
¿Cómo podemos acordarnos al cabo de un tiempo de qué era cada variable?. Por eso es
conveniente que aparte de indicar para qué sirve cada variable les demos nombres
descriptivos: