P. 1
El lenguaje BASIC Introducción

El lenguaje BASIC Introducción

4.6

|Views: 16.068|Likes:
Publicado porlaqr
Tutorial lenguaje basic
Tutorial lenguaje basic

More info:

Categories:Types, School Work
Published by: laqr on Jul 28, 2008
Copyright:Attribution Non-commercial

Availability:

Read on Scribd mobile: iPhone, iPad and Android.
download as PDF, TXT or read online from Scribd
See more
See less

07/24/2013

pdf

text

original

BASIC es un lenguaje de programación de propósito general que ofrece economía sintáctica, control de flujo, estructuras sencillas y un buen conjunto

de operadores. Es un lenguaje que no está especializado en ningún tipo de aplicación. Esto lo hace un lenguaje versátil y potente, con un campo de aplicación ilimitado y, sobre todo, se puede aprender rápidamente. En poco tiempo, un programador puede utilizar la totalidad del lenguaje. La palabra BASIC proviene de la expresión inglesa Beginner's All-purpose Symbolic Instruction Code: código de instrucciones simbólicas de propósito general para principiantes. El BASIC fue el primer lenguaje de programación desarrollado. Lo fue a mediados de la década de los sesenta por los profesores John G. Kemeny y Thomas E. Kurtz en el Dartmouth College, en California. Su código se basa en el vocabulario inglés y en las expresiones matemáticas. Consta de cientos de instrucciones para utilización de gráficos, procesado de textos, uso de variables, archivos, etc. EL BASIC utiliza un alfabeto formado por los caracteres alfabéticos: A -Z, cifras 0-9, caracteres especiales como operadores aritméticos: +, -, *, etc., y otros: (,),$, etc. El lenguaje BASIC es, originalmente, un lenguaje interpretado. Existen dos tipos de lenguaje: interpretados y compilados. Los interpretados son aquellos que necesitan del código fuente para funcionar (por ejemplo, GW -BASIC y QBasic). Los compilados, convierten el código fuente en un archivo objeto y éste en un archivo ejecutable. Este es el caso del lenguaje C y de las versiones más completas y recientes del BASIC. Existen muchas versiones (im plementaciones) del lenguaje BASIC. En el esquema siguiente se puede observar la evolución del desarrollo de los diferentes lenguajes de programación y, entre ellos, la de BASIC.

AÑO LENGUAJE
1900s BINARIO 1946 Plankalkul 1949 Short Code 1950 ASM (ensamblador) 1951 A-0 1952 AUTOCODE 1956 FORTRAN 1956 COBOL 1958 ALGOL 58 1960 LISP 1961 FORTRAN IV

INVENTOR
Bool Konrad Zuse

DESCRIPCION
primer lenguaje creado para jugar al ajedrez lenguaje traducido a mano lenguaje ensamblador

Grace Hopper Alick E. Glennie IBM

fue el primer compilador compilador muy rudimentario sistema de TRAducción de FORmulas matemáticas Compilador

IBM

Intérprete orientado a la Inteligencia Artificial sistema de TRAducción de FORmulas matemáticas

1961 COBOL 61 Extendido 1960 ALGOL 60 Revisado 1964 PASCAL 1964 BASIC 1965 SNOBOL 1965 APL 1965 COBOL 65 1966 PL/I 1966 FORTRAN 66 1967 SIMULA 67 1968 ALGOL 68 1968 SNOBOL4 1970s GW-BASIC 1970 APL/360 1972 SMALLTALK 1972 C 1974 COBOL 74 1975 PL /I 1977 FORTRAN 77 1980s SMALLTALK/V 1980 C con clases 1981 PROLOG IBM Digitalk Laboratorios Bell Ministerio Japonés de Comercio Internacional e Industria (MITI) Ministerio de Defensa de los EE.UU AT&T Bell Laboratories (Bjarne Stroustrup) Lenguaje sencillo sistema de TRAducción de FORmulas matemáticas pequeño y rapido lenguaje con clases Lenguaje estandar para la Inteligencia Artificial Centro de Investigación de Xerox en Palo Alto Laboratorios Bell pequeño y rapido lenguaje con tipos antiguo y clásico BASIC IBM sistema de TRAducción de FORmulas matemáticas sólo anotación Niklaus Wirth Universidad de Dartmouth (california) programación estructurada Beginners All Purpose Symbolic Instruction Code

1982 ADA

lenguaje muy seguro

1984 C++ 1985 CLIPPER 1985 QuickBASIC 1.0 1986 QuickBASIC 2.0 1987 QuickBASIC 3.0 1987 QuickBASIC 4.0 1987 CLIPPER SUMMER '87 1988 QuickBASIC 4.5 1989 QuickBASIC 7.1 1989 ASIC v5.0 1990s VISUAL C++ 1990s VISUAL BASICScript 1990 HTML

compilador compilador para bases de datos

Microsoft® Microsoft® Microsoft® Microsoft®

compilador de BASIC soporte de tarjeta gráfica EGA 43 lineas con la tarjeta EGA tarjetas Hercules, VGA compilador para bases de datos

Microsoft® Microsoft®

tarjeta SVGA ultima version de QuickBASIC interprete tipo QBASIC shareware

Microsoft® Tim Berners-Lee

lenguaje de script para internet

1991 QBasic 1.0 1993 XML 1993 SGML 1993 QBasic 1.1 1990s WML 1990s ASP 1990s PHP 1995 JAVA 1995 CLIPPER 5.01 1995 GNAT ADA95 1995 FORTRAN 95 1991 VISUAL BASIC 1.0 1992 VISUAL BASIC 2.0 1993 VISUAL BASIC 3.0 1994 VISUAL BASIC 4.0 1995 VISUAL BASIC 5.0 1998 VISUAL BASIC 6.0 1990s C# 2001 VISUAL BASIC .NET

Microsoft® C. M. SperbergMcQueen Charles F. Goldfarb Microsoft®

para MS-DOS 5.0. Compatible 99.9% con QuickBasic para internet para internet para MS-DOS 6.0 para internet

Microsoft®

para internet para internet

Sun Microsystems

para internet y proposito general compilador para bases de datos

Ministerio de Defensa de los EE.UU IBM Microsoft® Microsoft® Microsoft® Microsoft® Microsoft® Microsoft®

lenguaje muy seguro sistema de TRAducción de FORmulas matemáticas

Microsoft®

La evolución de Visual Basic

QuickBasic es un lenguaje de programación de alto nivel, que se puede utilizar de forma compilada. Tiene varios predecesores. El primero fue BasicA, desarrollado por Microsoft a principios de los 80. Sus características principales: tenía pocas instrucciones era un lenguaje interpretado se requería números identificativos de cada línea de có digo, haciendo la programación tediosa y limitada los archivos fuente se guardaban en un formato propio El siguiente predecesor de QuickBasic se denominaba GW -Basic, aparecido a finales de los 80 con algunas mejoras: 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: una interfaz de usuario bastante sencilla una extensa ayuda on-line que incluía índice, e ideas y ejemplos acerca de cómo usar cada instrucción utilidades básicas de edición, como búsquedas y sustituciones, cortado y pegado, etc., que aumentaban la productividad no era preciso incluir números de línea

Microsoft incluyó con el sistema operativo MS -DOS 5.0 una versión reducida de QuickBasic denominada QBasic 1.0. Esta versión y su actualización posterior, 1.1, se utilizaban sólo de forma interpretada pero sus posibilidades eran todavía bastante amplias. En lo que resta nos referiremos específicamente a la implementación de BASIC denominada QBasic por su versatilidad y sencillez de uso.

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. Un programa algo más complicado, pero que hace algo, es el siguiente:
' Este es mi primer programa en BASIC CLS PRINT "Bienvenido a la programación en lenguaj e BASIC" END

Con él visualizamos en la pantalla el mensaje:
Bienvenido a la programación en lenguaje BASIC

En el programa se incluye la línea:
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. La instrucción END termina el programa. Ni siquiera es obligatorio finalizar con END, aunque es conveniente por una cuestión de claridad. De cualquier manera, si extraemos esa sentencia, el programa funcionará exactamente igual (el programa finaliza automáticamente cuando no se encuentran más líneas de código). La inclusión de comentarios en un programa es una saludable práctica, como lo reconocerá cualquiera que haya tratado de leer un listado hecho por otro programador o por sí mismo, varios meses atrás. Para el intérprete o el compilador, los comentarios son inexistentes, por lo que no generan líneas de código ejecutable, permitiendo abundar en ellos tanto como se

desee. En el lenguaje BASIC se toma como comentario todo carácter que sigue a la comilla simple: ' o a la palabra clave REM. Como se observa, un programa en QBasic es simplemente un fichero de caracteres que contiene un conjunto de instrucciones que un programa especial, el intérprete, se encarga de transformar en un código que la computadora puede ejecutar (aunque no se genera un archivo .EXE). Antes de continuar hagamos un inciso sobre la nomenclatura utilizada en QBasic para designar a distintos elementos del lenguaje: Elemento Sentencia Instrucción (Comando) Palabra clave Keyword Cadena String Número Definición Es una instrucción que realiza una operación. Se utilizan estas palabras de forma intercambiable. Se usa mucho la forma comando debido a su utilización en inglés. Una palabra que forma parte del lenguaje QBasic. Cuando se utiliza una palabra clave en una sentencia, QBasic automáticamente la convierte a mayúsculas. No se puede utilizar una palabra clave para dar nombre a una constante o variable (palabra reservada). Una cadena de texto (caracteres). En Qbasic se delimita con comillas, por ejemplo, "Bienvenido". La cadena "" (vacía) es válida. Designa a números enteros, decimales de precisión simple y 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 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 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 aritméticos, relacionales o lógicos. Devuelve una cadena o un número. Puede tomar uno o más parámetros de entrada para calcular el result ado. No hace nada en el programa. Se utiliza como una nota explicativa 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, que guardan una relación de algún tipo entre sí. Designa a un grupo de líneas que se ejecutan una serie de veces.

Constante

Variable

Operador Función Comentario Bloque Bucle

La estructura general de un módulo de código en QBasic consta de un programa principal y de varios subprogramas y/o funciones:
' Programa principal declaración de funciones y subprogramas declaración de variables sentencias END SUB Subprograma1 ( )

declaración de variables sentencias 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

Cuando la envergadura del programa es grande se suele fragmentar el módulo en varias partes, incluyendo cada parte en un fichero s eparado. Normalmente colocaremos en cada fichero todas las subrutinas y funciones que se encarguen de una tarea del programa. Por tanto, un programa en QBasic puede estar formado por diferentes módulos o fuentes. Es conveniente mantener los fuentes de un t amaño no muy grande -para encadenar la ejecución de los diferentes módulos se utiliza la instrucción CHAIN (CHAIN nombre.archivo$-.

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:
' Multiplica dos números enteros DIM multiplicador AS INTEGER un entero DIM resultado AS INTEGER entero multiplicador = 1000 ' defino <multiplicador> como ' defino <resultado> como un

' asigno valores

resultado = 2 * multiplicador PRINT "Resultado = ", resultado END ' muestro el resultado

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.

Identificadores, tipos y tamaños
Para dar un nombre a una variable tenemos qu e 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 identificado res correctos e incorrectos: Correcto
cuenta prueba23

Incorrecto
1cuenta 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 identific ador 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 entero DIM numero% entero DIM frase AS STRING ' crea DIM frase$ ' crea DIM a!, b# ' crea de precisión simple y doble, respect. DIM a AS SINGLE, b AS DOUBLE la variable frase, de tipo cad ena la variable frase, de tipo cadena dos variables a y b, de tipo número ' crea dos variables a y b, ... ' crea la variable numero, de tipo número ' crea la variable numero, de tipo número

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 DIM frase$ = "Hola"

' incorrecto, falla el intérprete ' 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: cadenas de caracteres números enteros números en coma flotante Sufijo Tamaño conjunto de STRING $ caracteres (de 8 bits)
INTEGER

Tipo

Intervalo 0 a 32 767 caracteres

Descripción 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).

%

16 bits

Las variables enteras almacenan números enteros (sin -32 768 a 32 parte decimal). 767 Ejemplos: 4323, 1, -7543, 30000 (no se utilizan separadores de millares). -2 147 483 648 Almacenan también enteros. a 2 147 483 Ejemplos: 54500, 0, 123456789. 647 3.4 E-38 a 3.4E+38 (aprox. 6 dígitos de precisión) 1.7 E-308 a 1.7 E+308 (aprox. 12 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. Las variables de precisión doble almacenan números de coma flotante con 12 dígitos de precisión. Ejemplos: 10000000000000000000000000000000000000000000, .000000000000000400005.

LONG

&

32 bits

SINGLE

!

32 bits

DOUBLE

#

64 bits

Veamos el siguiente programa de ejemplo acerca del uso de variables:
' Convierte grados Centígrados a Fahrenheit DIM cels!, fahr! cels = 25 fahr = 32 + 9 * fahr / 5 ' Temperatura en º C ' 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 instrucción LET
La sentencia LET asigna un valor a una variable. La sintaxis de uso es:

[LET] variable = expresión 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#

Ámbito o alcance de las variables
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: 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ó. 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, 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: Variable Global
' Muestra un númer o entero Valor PRINT x1% END SUB Valor SHARED x1% ' Aquí sólo se escribe SHARED, ' no DIM SHARED x1% = 100 END SUB

Variable Local
' 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 ejec utar el programa es en el primer caso:
100

mientras que en el segundo:
0

Introducción: funciones para E/S de datos
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

Otras que permiten el control de la salida por pantalla son:
LOCATE CLS

PRINT: Salida por pantalla

Comenzaremos con la instrucción principales de salida de datos: PRINT. 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:
' Muestra un mensaje 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:
' Muestra un mensaje PRINT "Hola"; PRINT "mundo" END

cuyo resultado es:
Hola mundo

Un ejemplo de uso con valores numéricos y de texto es:

' Muestra valores numéricos a% = 50 b% = 100 PRINT "El valor de a es"; a%; " y el valor de b es"; b% END

cuyo resultado es:
El valor de a es 50 y el valor de b es 100

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. Si en lugar de utilizar ; se utiliza , para la concatenación:

' Muestra valores numéricos a% = 50 b% = 100 PRINT "El valor de a es", a%; " y el valor de b es", b% END

el resultado es:

El valor de a es

50 y el valor de b es

100

es decir, produce una separación de 14 espacios.

INPUT: lectura del teclado
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:
' Lee un número entero desde el teclado DIM num% PRINT "Introduce un número"; INPUT num% PRINT "Has tecleado el número"; num% END

Este programa muestra el mensaje Introduce un número? (nótese la interrogación añadida) y espera a que el usuario introduzca un entero. Si el usuario escribe 23 y pulsa INTRO lo que se observa es:
Introduce un número? 23 Has tecleado el número 23

Podemos preguntar por más de una variable a la vez en un solo INPUT:
' Lee varios enteros desde el teclado DIM a%, b%, c% PRINT "Introduce tres números"; INPUT a%, b%, c%

PRINT "Has tecleado los números"; a%; b%; c% END

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.
Introduce tres números? 1,2,3 Has tecleado los números 1 2

3

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í:
' Lee un entero desde el teclado DIM num% INPUT "Introduce un número: ", num% PRINT "Has tecleado el número"; num% END

que produce la salida:
Introduce un número: 23 Has tecleado el número 23

La utilización de INPUT para introducción de cadenas de texto es similar:
' Lee una cadena de caracteres desde el teclado DIM palabra AS STRING INPUT "Escribe una palabra: ", palabra PRINT "He guardado: "; palabra END

cuyo resultado es, si se escribe el texto y se pulsa INTRO:
Escribe una palabra: Tecnología He guardado: Tecnología

Se puede limitar el tamaño de la cadena que se almacena si se especifica la longitud máxima de dicha cadena en la instrucción DIM:
DIM palabra AS STRING*5 cadena de texto caracteres ... ... ' Define palabra como una ' de una longitud máxima de 6

en este caso el resultado es:
Escribe una palabra: Tecnología He guardado: Tecno

PRINT USING

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:
PRINT USING formato; l ista_de_expresiones

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 ,. Los especificadores que se pueden utilizar en formato son: Caracteres que dan formato a una expresión numérica
# Posición de dígito. Después del dígito, imprime . Posición de punto decimal. signo para los números , A la izquierda del punto decimal, negativos. imprime una coma cada 3 dígitos. Imprime $ adelante. + Posición del signo de número. espacios adelante con * ^^^^ Imprime con f ormato exponencial. Combina ** y $$. ¦ ¦ ¦ ¦ $$ ¦ ** ¦ **$ Llena el

Caracteres que dan formato a una expresión de texto
& Imprime la cadena completa. Imprime los primeros n ! Imprime sólo el primer carácter caracteres, donde n es el de la cadena. de espacios entre ¦ \ \ ¦ ¦ número

Caracteres utilizados para imprimir caracteres literales
_ Imprime el carácter de formato Cualquier carácter que no siguiente como li teral. en la tabla será impreso como literal. ¦ ¦ ¦ esté

Veamos un ejemplo en el que se da formato a expresiones numéricas y de texto:
' Calcula el importe total de un conjunto de productos INPUT "Introduzca el nombre del producto: ", nombreitem$ INPUT "¿Cuántos elementos?: ", numitems% INPUT "¿Cuál es el importe unitario?: ", importeitem! importetotal! = numitems% * importeitem! PRINT PRINT "Producto Cantidad Importe Importe Total" PRINT "-------- -------- --------- -------------" PRINT USING "\ \ ##,### ###,###.## #,###,###.##"; nombreitem$; numitems%; importeitem!; importetotal! END

Este programa produce el resultado:

Introduzca el nombre del producto: relé ¿Cuántos elementos?: 30 ¿Cuál es el importe unitario?: 1.5 Producto Cantidad Importe Importe Total -------- -------- --------- ------------relé 30 1.50 45.00

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:
' Lee una cadena de caracteres desde el teclado DIM frase AS STRING LINE INPUT "Escribe una frase: ", frase PRINT "He guardado: "; frase END

Si al ejecutar este programa se introduce la primera oración del Quijote se obtiene:
Introduce una frase: En un lugar de la Mancha, de cuyo nombre ... He guardado: En un lugar de la Mancha, de cuyo nombre ...

Posicionado del cursor y borrado de pantalla

LOCATE: posicionado del cursor
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:
' Muestra Hola en la fila 20, columna 10 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

(clear screen, borrar pantalla). 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.
' Borra pantalla y muestra mensaje CLS PRINT "Hola" END

Introducción
Los subprogramas y funciones son rutinas, procedimientos o conjuntos de sentencias que realizan una labor específica. Los subprogramas o subrut inas nacieron de la necesidad de no repetir innecesariamente un trabajo ya hecho. Pueden invocarse desde el cuerpo del programa principal cuantas veces se desee. Están en el núcleo de lo que se denomina programación estructurada. En QBasic existen dos clas es de subrutinas o procedimientos: los subprogramas propiamente dichos (procedimientos SUB), que realizan un conjunto de tareas y no devuelven ningún valor. las funciones (procedimientos FUNCTION ), que devuelven un valor de un tipo que se puede especificar. Los subprogramas y las funciones admiten parámetros (argumentos), que son datos que le pasan al procedimiento las sentencias que la llaman. La sintaxis habitual en la definición de un subprograma es:
SUB identificador [(lista_de_parámetros)] bloque_de_código END SUB

donde:
- identificador es el nombre del subprograma. Debe ser un identificador valido; - lista_de_parámetros es una lista de variables, separadas por comas, que conforman los datos

que le pasamos al subprograma. - bloque_de_código es un conjunto de sentencias. La lista de parámetros o argumentos es opcional. Podemos escribir como ejemplo:

' Ejemplo de uso de un subprograma hola END ' Subprograma que muestra un mensaje de bienvenida SUB hola 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ó. La sintaxis habitual en la defi nición de una función es:
FUNCTION identificador [tipo] [(lista_de_parámetros)] bloque_de_código nombre_de_la_función = expresión bloque_de_código END FUNCTION

donde:
- identificador es el nombre de la función. Debe ser un identificador valido; - tipo es un sufijo [%, !, etc] o una expresión AS INTEGER , AS SINGLE , etc. que define

el tipo de datos que devlelve la función. - lista_de_parámetros es una lista de variables, separadas por comas, que conforman los datos que le pasamos a la función. - nombre_de_la_función = expresión es una sentencia que produce que la función retorne el valor determinado por expresión. - bloque_de_código es un conjunto de sentencias. El tipo es opcional. La lista de argumentos es también opcional. Podemos escribir como ejemplo:
' Ejemplo de uso de una función INPUT "Introduce dos enteros: ", s1%, s2% PRINT "La suma es: "; Suma%(s1%, s2%) END ' Función que suma dos enteros y devuelve la suma como otro entero FUNCTION Suma% (s1%, s2%) 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

donde el valor de expresión es el que se asigna a la función. Por ejemplo:
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).

Paso de parámetros a un subprograma
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í:
SUB imprime (numero%, letra$) PRINT numero%, letra$ 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.) Por ejemplo, el programa:
' Imprime valores

n% = 1 l$ = "A" CLS PRINT n% imprime n%, l$ PRINT n% END SUB imprime (numero%, letra$) numero% = 2 PRINT numero%, letra$ END SUB

da como resultado:
1 2 2

A

Es decir, la variable n, que originalmente valía 1, toma el valor 2 tras la llamada al procedimiento imprime.

Declaración y comprobación de tipos
Al igual que para las variables, cuando un procedimiento (función o subprograma) se va a usar en un programa, o cuando un procedimiento se define en otro fichero (procedimiento externo), se debe declarar antes del lugar donde se define. La declaración de un procedimiento consiste en especificar el tipo de datos que va a retornar, cuando se trata de una función, y el número de argumentos y su tipo. Una declaración típica de función es:
DECLARE {FUNCTION | SUB} nombre_del_procedimiento[sufijo] [([lista_de_parámetros])]

Esto avisa al intérprete/compilador de que el procedimiento lo vamos a definir después. 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:
DECLARE FUNCTION imprime$(numero AS INTEGER, letra AS STRING) DECLARE FUNCTION imprime$(numero%, letra%)

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. Véase, por ejemplo, el programa:
DECLARE FUNCTION imprime$ (numero%, char$) "imprime" ' Ejemplo DIM caracter AS STRING CLS caracter = imprime(100, "a") PRINT "El carácter escrito fue ";caracter END ' ' Define una función que imprime un entero y un carácter. Devuelve el mismo carácter de entrada. ' Declara la función

FUNCTION imprime$(numero AS INTEGER, letra AS STRI NG) PRINT numero, letra 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.
DECLARE SUB BorraPantalla () ' LLamada a un subprogra ma sin argumentos BorraPantalla ' Llamamos al subprograma ' También podríamos escribir: CALL BorraPantalla END SUB BorraPantalla CLS PRINT "La pantalla está limpia" END SUB

Subprograma con argumentos (no devuelve nada) En este ejemplo la función compara toma dos números, los compara y nos dice cuál es mayor.
DECLARE SUB compara (a AS INTEGER, b AS INTEGER) ' Compara números

DIM num1 AS INTEGER, num2 AS INTEGER INPUT "Introduzca dos números: ", num1, num2 compara num1, num2 argumentos compara(num1, num2) END SUB compara (a AS INTEGER, b AS I NTEGER) a y b a la función IF a > b THEN PRINT a; " es mayor que "; b ELSE PRINT b; " es mayor que "; a END IF END SUB ' Pasamos los parámetros ' Llamamos al subprogramas con sus dos ' También podríamos escribir: CALL

Función con argumentos (devuelve un valor) Este ejemplo es como el anterior pero devuelve como resultado el mayor de los dos números.
DECLARE FUNCTION compara% (a AS INTEGER, b AS INTEGER) ' Compara números DIM num1 AS INTEGER , num2 AS INTEGER DIM resultado AS INTEGER INPUT "Introduzca dos números: ", num1, num2 resultado = compara(num1, num2) resultado el valor que devuelve la función ' Almacenamos en

PRINT "El mayor de los dos es "; resultado END FUNCTION compara% (a AS INTEGER, b AS INTEGER) parámetros a y b a la función IF a > b THEN compara% = a ELSE compara% = b END IF END FUNCTION ' Pasamos los

En este ejemplo podíamos haber hecho también:
PRINT "El mayor de los dos es "; compara(num1, num2)

De esta forma nos hubiésemos ahorrado tener que definir la variable resultado .

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
La primera sentencia de control es la sentencia if. Admite dos tipos de sintaxis:
IF expresión THEN sentencia_1 [ELSE sentencia_2]

o también:
IF expresión THEN [bloque_sentencias_1] [ELSEIF expresion_2 THEN [bloque_sentencias_2]]... ELSE [bloque_sentencias_n] END IF

Esta sentencia es equivalente a la que poseen la mayoría de lenguajes de programación y sirve para bifurcar en un punto de programa. Permite al programa tomar dec isiones. En su primera forma, la sentencia_1 sólo se ejecuta si el resultado de evaluar la expresión es verdadero (no cero); en caso contrario, se ejecuta sentencia_2 . En la segunda forma, tenemos varias posibilidades: si al evaluar la expresión el resultado es verdadero se ejecutan las instrucciones bloque_ sentencias_1 , pero si el resultado es falso se evalúa la expresión_2 y si ésta es verdadera se ejecuta bloque_sentencias_2, y así sucesivamente. En cualquier caso sólo una de los bloques de sentencias s e ejecuta. Veamos algunos ejemplos:
IF num% = 1 THEN PRINT "la variable num vale 1" PRINT "la variable num no vale 1" ELSE

Tras evaluarse la expresión IF y ejecutarse la sentencia adecuada, el programa continúa con la línea siguiente a la de la última se ntencia del IF. Para la sentencia IF vale como expresión cualquiera válida en QBasic, incluso las llamadas a funciones:
IF suma(num1, num2) >= 0 THEN PRINT "La suma de num1 y num2 es positiva" END IF

Como sentencias valen cualquier tipo de sentencia válida en QBasic, entre ellas la propia sentencia IF. En este caso hablaremos de sentencias IF anidadas. Por ejemplo:
IF num > 0 THEN IF num = 1 THEN PRINT "num es igual a 1" ELSEIF num > 1 THEN PRINT "num es mayor que 1" ELSE PRINT "num es menor que 1" END IF 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
Un bucle es un conjunto de sentencias que se ejecutan repetidamente hasta que se alcanza una condición de fin de bucle, o condición de salida. El bucle while es el tipo de bucle más sencillo. En su modo más simple se escribe:
WHILE expresión bloque_sentencias WEND

El bucle while comienza por evaluar la expresión . Si es cierta, se ejecuta bloque_sentencias . Entonces se vuelve a evaluar la expresión . De nuevo, si es verdadera, se vuelve a ejecutar bloque_sentencias . Este proceso continúa hasta que el resultado de evaluar la expresión es falso. Por esto se le llama a esta expresión la condición de salida. Por ejemplo:
variable% = 10 WHILE variable% >= 1 PRINT "la variable vale "; variable% 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
La sintaxis de este bucle es:
DO [{WHILE | UNTIL} expresión] bloque_sentencias LOOP

o también:
DO bloque_sentencias LOOP [{WHILE | UNTIL} expresión]

Su funcionamiento es análogo el del bucle WHILE, salvo que la expresión de control se puede evaluar al final del bucle (si se utiliza la segunda opc ión de sintaxis). Esto nos garantiza que el bucle DO_WHILE se ejecuta al menos una vez. Incluye también la posibilidad de ejecutar el bucle mientras ( WHILE ) expresión sea verdadera o hasta ( UNTIL) que expresión sea verdadera. 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
La sintaxis del bucle FOR es:
FOR contador = inicio TO fin [STEP incremento] bloque_sentencias NEXT [contador]

Este bucle se utiliza para realizar un conjunto de acciones un número determinado de veces.Su versión más sencilla es:
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

Y en este ejemplo se muestran los valores 1, 3, 5, 7 y 9 (desde 1 con un incremento de 2). El bucle FOR es equivalente a un bucle WHILE escrito del siguiente modo:
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 .

Las sentencia EXIT
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:
EXIT {DO | FOR}

La sentencia EXIT rompe la ejecución de un bucle o bloque de instrucciones y continúa en la instrucción que sigue al bucle o bloque. Por ejemplo:
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 PRINT INPUT IF a$ NEXT 10 i% a$ = "S" THEN EXIT FOR

el cual imprime enteros entre 1 y 10 h asta que se introduce por teclado la la pulsación S.

también se utiliza con procedimientos SUB o FUNCTION , para abandonar el procedimiento antes de ejecutar todas las sentencias que preceden al correspondiente END
EXIT {SUB | FUNCTION}.

La sentencia de selección múltiple SELECT CASE
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:
SELECT CASE expresión_control CASE lista_expresiones_1 bloque_sentencias_1 [CASE lista_expresiones_2] [bloque_sentencias_2]]... [CASE ELSE [bloque_sentencias_n]] END SELECT

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: primero se evalúa la expresión de control. A continuación se compara con lista_expresiones_1 de la primera etiqueta CASE. Si son iguales, se ejecuta bloque_ sentencias_1 . Si no, se compara con lista_expresiones_2 , y así sucesivamente. Se repite el proceso hasta agotar todas las etiquetas case. Si al llegar a la etiqueta ELSE no se ha ejecutado ninguna sentencia ésta es la acción por defect o. La etiqueta ELSE es opcional. Si no la ponemos el programa simplemente salta fuera del SELCT CASE. Vamos a ver un ejemplo de múltiples casos con IF y luego con SELECT CASE :
' Ejemplo de selcción con IF DIM num AS INTEGER INPUT "Introduce un número " , num IF num = 1 THEN PRINT "Es un ELSEIF num = 2 THEN PRINT "Es un ELSEIF num = 3 THEN PRINT "Es un ELSE PRINT "No es END IF END

1" 2" 3" ni 1, ni 2, ni 3"

Ahora con SELECT CASE :
' Ejemplo de selección con SELCT CASE DIM num AS INTEGER INPUT "Introduce un número ", num

SELECT CASE num CASE 1 PRINT "Es un 1" CASE 2 PRINT "Es un 2" CASE 3 PRINT "Es un 3" CASE ELSE PRINT "No es ni 1, ni 2, ni 3" END SELECT END

Como vemos, el código con SELECT CASE es más cómodo de leer. Esta sentencia tiene además otras posibilidades. Veamos el siguiente ejemplo:
' Otro ejemplo INPUT "Escriba nivel de riesgo aceptable (1 -10): ", Total SELECT CASE Total CASE IS >= 8 PRINT PRINT de valores." CASE 3 TO 7 PRINT PRINT corporaciones." CASE 1, 2 PRINT PRINT END SELECT END

"Riesgo y ganancia máximos." "Seleccione plan de inversiones en bolsa

"Riesgo y ganancia de moderados a altos." "Seleccione fondo mutuo o bonos de

"Sin riesgo, pocas ganancias." "Seleccione plan de pensión individ ual."

En él observamos que en lista_expresiones se pueden utilizar las siguientes formas:
expresión[, expresión] ... expresión TO expresión IS operador_relacional expresión

Introducción
Una posible definición de array sería: "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í:
' Declaramos 24 variables, una para cada hora del día DIM temp1!, temp2!, temp3!, temp4!, temp5!, temp6!, temp7!, temp8!

DIM temp9!, temp10!, temp11!, temp12!, temp13!, temp14!, temp15!, temp16! DIM temp17!, temp18!, temp19!, temp20!, temp21!, temp22! , temp23!, temp0! DIM media! ' Asignamos el valor de cada una INPUT "Introduzca las temperaturas desde las 0 hasta las 23 separadas por comas: ", temp0!, temp1!, ... temp23! media = ( temp0! + temp1! + temp2! ... + temp23! ) / 24 PRINT "La temperatu ra media es "; media! 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:
DIM temp!(24) DIM media! DIM hora% ' Con esto declaramos las 24 variables

' Ahora damos valor a cada una FOR hora% = 0 TO 23 PRINT "Introduzca temperatura de las"; hora%; "horas: "; INPUT "", temp!(hora%) media! = media! + temp!(hora%) NEXT hora% media! = media! / 24 PRINT "La temperatura media es "; media!

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 . La parte final de la definición dice: y se distinguen mediante el índice . En el ejemplo recorremos la matriz mediante u n bucle FOR y vamos dando valores a los distintos elementos de la matriz. Para indicar a qué elemento nos referimos usamos un número entre paréntesis (en este caso la variable hora ), este número es lo que se llama índice del array. 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

No hay que confundirse. En la declaración del array el número entre corchetes es el número total de elementos; en cambio, cuando usamos la matriz, el número entre corchetes es el índice.

Declaración de un array
La forma general de declarar un array es la siguiente:
DIM identificador_del_array[sufijo_tipo_dato](dimensión) [AS tipo_de_dato]

donde: el sufijo_tipo_dato o tipo_de_dato indican uno de los tipos de datos conocidos ( %, !, INTEGER, SINGLE , etc). En el ejemplo era SINGLE (!) El identificador_del_array es el nombre que le damos (en el ejemplo era temp). La dimensión es el número de elementos que tiene el array. Como se ha indicado antes, al declarar un array reservamos en memoria tantas variables del tipo_de_dato como las indicada en dimensión . también se puede especificar dando los límites superior e inferior de los subíndices del array:
dimensión DIM identificador_del_array[sufijo_tipo_dato]( [inferior TO] superior )

En el ejemplo anterior podríamos haber puesto también:
DIM temp(0 TO 23) AS SINGLE variables ' Con esto declaramos las 24

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:
DIM temp!(24), hora% 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%

dará como resultado:
La temperatura a las 0 era de 0 grados. La temperatura a las 1 era de 0 grados.

La temperatura La temperatura ... La temperatura ... La temperatura ... La temperatura La temperatura La temperatura La temperatura

a las 2 era de 0 grados. a las 3 era de 0 grados. a las 9 era de 20 grados. a la s 12 era de 25 grados. a a a a las las las las 20 21 22 23 era era era era de de de de 23 grados. 0 grados. 0 grados. 0 grados.

Vemos que los elementos a los que no se ha asignado valor inici al son nulos

Arrays de más de una dimensión
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. Supongamos que deseamos controlar mensualmente las temperaturas registradas durante todo un mes. Podemos definir una matriz que dependa de dos índices: el día del mes y la hora del día. Por ejemplo:
DIM temp!(31,24) DIM dia%, hora% ' Matriz de temperaturas "día,hora"

' Ahora damos valor a cada una FOR dia%=1 TO 31 FOR hora% = 0 TO 23 PRINT "Introduzca la temperatura del día";dia%;"a las"; hora%; "horas: "; INPUT "", temp!(dia%,hora%) PRINT "La temperatura introducida es: "; temp!(dia%,hora%) NEXT hora% NEXT dia%

Vemos que para dimensionar la matriz no tenemos más que utilizar:
DIM matriz(dimension1,dimension2)

o también:
DIM matriz(inferior_1 TO superior_1, infe rior_2 TO superior_2)

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). Esto es generalizable a más dimensiones.

Paso de un array a un procedimiento
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:
DECLARE FUNCTION sumar% (m() AS INTEGER) cuyo argumento es una matriz ' Ejemplo de paso de un array a una función DIM matriz(10) AS INTEGER FOR contador% = 1 TO 10 matriz(contador%) = 2*contador% valores a los elementos PRINT contador%, matriz(contador%) NEXT contador% PRINT "La suma es "; sumar(matriz()) END FUNCTION sumar%( m() AS INTEGER ) sin especificar la dimensión suma% = 0 FOR i% = 0 TO 10 suma% = suma% + m(i%) NEXT i% sumar = suma% END ' Declara la función

' Asigna

' El argumento es el array m()

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.

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.

Lectura de archivos. Operaciones y funciones básicas
Para comenzar, vamos a analizar un ejemplo que lee un fichero de texto ( origen.txt ) y muestra su contenido en la pantalla:
' Lee un archivo de texto línea a línea DIM linea AS STRING OPEN "origen.txt" FOR INPUT AS #1 lectura ' Abre el archivo para

PRINT "Contenido del f ichero:" DO WHILE NOT EOF(1) ' Comprueba si se ha alcanzado el fin del archivo LINE INPUT #1, linea ' Lee una línea del archivo (hasta RC/LF: salto de línea) PRINT linea LOOP CLOSE #1 END ' Cierra el archivo

Analizaremos este ejemplo poco a poc o deteniéndonos en:

Apertura del fichero para lectura: OPEN
Ahora es preciso abrir el fichero. Para ello usamos la función OPEN. Esta sentencia tiene el siguiente formato:
OPEN nombre_archivo$ [FOR modo] AS [#]nº_archivo%

En el ejemplo usábamos:
OPEN "origen.txt" FOR INPUT AS #1

El nombre de fichero se puede indicar directamente (como en el ejemplo) o usando una variable y se puede abrir de diversas formas. Esto se especifica con el parámetro modo. Los modos posibles son:
INPUT OUTPUT RANDOM

APPEND

BINARY

especifica que el archivo va a ser abierto para leer información de forma secuencial. 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 aleatorio. RANDOM es el modo de archivo predeterminado. especifica que el archivo va a ser abierto para añadir información de 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 leer o escribir información en cualquier posición de byte del archi vo usando instrucciones GET o PUT.

es un identificador que permite distinguir los distintos ficheros que se utilizan, cuando se usan varios simultáneamente.
nº_archivo

Lectura de caracteres del fichero: LINE INPUT #
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:
[LINE] INPUT #nº_archivo, variable$

En este caso lo usamos como:
LINE INPUT #1, linea

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.

Comprobación de fin de fichero: EOF()
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(). Esta función es de la forma:
EOF(nº_archivo)

Esta función comprueba si se ha llegado al final de nº_archivo , en cuyo caso devuelve un valor verdadero (no 0). Si no se ha llegado al final de fichero devue lve falso (0). Por eso lo usamos del siguiente modo:
DO WHILE NOT EOF(1)

o
DO UNTIL EOF(1)

Cierre del fichero: CLOSE
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

Aquí nº_archivo es el identificador del archivo indicado en OPEN cuando el archivo se abrió:
CLOSE #1 CLOSE

sin argumentos cierra todos los archivos abiertos.

Lectura de caracteres del fichero: INPUT$()
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. Por ejemplo, el siguiente programa muestra todo el contenido del fichero "origen.txt" byte a byte. ' Lee un archivo de texto carác ter a carácter DIM letra AS STRING*1 OPEN "origen.txt" FOR INPUT AS #1 lectura PRINT "Contenido del fichero:" DO WHILE NOT EOF(1) ' Comprueba si se ha alcanzado el fin del archivo letra = INPUT$(1,1) ' Lee un carácter del ar chivo PRINT letra; LOOP CLOSE #1 END ' Cierra el archivo ' Abre el archivo para

Escritura de archivos. Operaciones y funciones básicas
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).
' Ejemplo de escritura de archivos DIM linea AS STRING OPEN "origen.txt" FOR INPU T AS #1 para lectura OPEN "destino.txt" FOR OUTPUT AS #2 destino para escritura DO WHILE NOT EOF(1) LINE INPUT #1, linea origen PRINT #2, linea archivo destino PRINT linea LOOP CLOSE #1, #2 END ' Muestra contenido en pantalla ' Escribe la línea en el ' Abre el archivo origen ' Abre el archivo

' Lee una línea del archivo

Como en el caso de la lectura de archivos, analizaremos este ejemplo poco a poco deteniéndonos en:

Apertura del fichero para escritura: OPEN
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:
OPEN "destino.txt" FOR OUTPUT AS #2

Escritura de caracteres en el arc hivo: PRINT #
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:
PRINT #nº_archivo, lista_expresioens

En este caso lo usamos como:
PRINT #2, linea

De esta forma vamos escribiendo en el fichero destino.txt el contenido del fichero origen.txt . Si hubiésemos escrito la anterior instrucción así:
PRINT #2, linea;

(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)

Comprobación fin de fichero
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.

Cierre del fichero: CLOSE
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

Obsérvese que cerramos ambos archivos con una única instrucción.

Otras funciones para el manejo de ficheros

WRITE
Esta sentencia es muy similar a PRINT # , de hecho, la sintaxis es idéntica:
WRITE #nº_archivo, lista_expresioens

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:
OPEN "destino.txt" FOR OUTPUT AS #1 PRINT #1, 1, 2, "Tecnología" WRITE #1, 1, 2, "Tecnología" CLOSE #1

Como resultado, en el archivo "destino.txt" se escribirá: 1 2 Tecnología 1,2,"Tecnología"

GET y PUT
lee información de un archivo colocándola en un buffer de acceso aleatorio o en una variable. PUT escribe una variable o un buffer de acceso aleatorio en un archivo.
GET

La sintaxis es:
GET [#]numarchivo%[,[numregistro&][,variable]] PUT [#]numarchivo%[,[numregistro&][,variable]] numarchivo% es el número de un archivo abierto. numregistro&: para archivos de acceso aleatorio, es el

número del regi stro que será leído o escrito. Para archivos binarios la posición de byte donde se inicia el proceso de leer o escribir. variable Para GET, es una variable utilizada para recibir información del archivo. Para PUT, una variable que contiene la información de salida que ser escrita en el archivo. La variable generalmente tiene el tipo de datos definido por el usuario. Por ejemplo:
TYPE RegistroPrueba ' Define un tipo de datos con un texto de 20 caracteres y un número de precisión simple Alumno AS STRING * 20

Nota AS SINGLE END TYPE DIM MiClase AS RegistroPrueba anterior

' Declara una variable edl tipo

OPEN "FINAL.DAT" FOR RANDOM AS #1 LEN = LEN(MiClase) MiClase.Alumno = "Pérez Ruiz" MiClase.Nota = 9 PUT #1, 1, MiClase CLOSE #1 OPEN "FINAL.DAT" FOR RANDOM AS #1 LEN = LEN(MiClase) GET #1, 1, MiClase PRINT "Estudiante:"; MiClase.Alumno PRINT "Nota:"; MiClase.Nota CLOSE #1

Este programa produce la salida:
Estudiante: Pérez Ruiz Nota: 9

Posicionamiento en el fichero: LOC y SEEK
Supongamos que queremos posicionarnos en un byte concreto de un archivo para leer o escribir en dicha posición. La función LOC devuelve la posición actual del puntero del archivo identificado por nº_archivo . Su sintaxis es:
LOC(nº_archivo%)

La instrucción SEEK establece la posición del archivo para la siguiente acción de lectura o escritura:
SEEK [#]nº_archivo%, posición& numarchivo% es el número de un archivo abierto. posición& es la posición donde ocurrirá la siguiente acción de leer o

escribir. Para archivos de acceso aleatorio, un número de registro. Para otros archivos, la posición de byte con relación al principio del archivo. El primer byte ocupa la posición 1.
OPEN "prueba.txt" FOR RANDOM AS #1 FOR i% = 1 TO 10 PUT #1, , i% NEXT i% SEEK #1, 2 ' Se posiciona en el segundo registro GET #1, , i% ' Lee el registro donde se halla posicionado PRINT "Datos: "; i%; " Registro actual : "; LOC(1)

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 :
Datos: 2 Registro actual: 2

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. Al igual que en determinadas circunstancias es preciso comunicarse con dispositivos externos, también es necesario intercamb iar información con el propio PC. Ello se realiza con frecuencia leyendo y escribiendo valores en/a determinadas posiciones de la memoria del mismo. Por ejemplo, podemos conocer el estado en el que se encuentra el teclado del PC sin más que acceder al valo r almacenado en el segmento 0x40, offset 0x17 de la memoria. Con él podemos discernir si la tecla "bloq mayús" está pulsada o no, si la tecla "Alt" está pulsada o no, etc. Asimismo, podemos recoger información del hardware actualmente instalado en el PC y, entre otras cosas, determinar en qué direcciones de E/S se hallan los puertos hardware mencionados en el párrafo anterior. Así existen en QBasic algunas funciones que proporcionan acceso a la memoria.

Acceso a los puertos hardware

Lectura del puerto
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. Esta función se utiliza de la siguiente manera:
valor% = INP(puerto_dir)

donde: es la dirección (valor entero: 0-65.535) que identifica el puerto hardware de la cual se quiere leer y valor% y es una variable entera en la que se almacena el byte leído (0 255).
puerto_dir

En el siguiente ejemplo vamos a obtener un byte del puerto paralelo (bidireccional ) instalado en el PC (en la dirección de E/S 378h): %
' Lee un byte del puerto paralelo

DIM valor AS INTEGER DIM puerto AS INTEGER: puerto = &H378 ' dirección del puerto paralelo valor = INP(puerto) PRINT "El byte leído del puerto "; puerto; " es "; va lor END

Escritura en el puerto
Para enviar información a un puerto hardware ( escritura en el puerto), Qbasic proporciona la función OUT. Esta función envía un byte a un puerto (hardware) de E/S. La sintaxis de la función es:
OUT puerto_dir%, valor%

donde: es la dirección del puerto hardware en la cual se quiere escribir (un entero: 0-65.535); valor es el byte (0-255) que se envía al puerto.
puerto_dir

En el siguiente ejemplo vamos a enviar la letra C al primer puerto paralelo bidireccional instalado en el PC (en la dirección de E/S 378h):
' Envía un carácter al puerto paralelo DIM valor AS INTEGR DIM puerto AS INTEGER: puerto = &H 378 ' dirección del puerto paralelo valor = ASC("C") letra C (el entero: 67) ' valor contiene el código ASCII de la

OUT puerto, valor PRINT "Valor "; valor; " enviado al puerto "; puerto END

Acceso a la memoria

Lectura de la memoria
Para leer la información almacenada en la memoria, QBasic proporciona la función PEEK. Ésta devuelve el valor de byte almacenado en la posición d e memoria designada por segmento:offset (direccionamiento segmentado de la memoria). Esta función se declaran de la siguiente manera:
valor% = PEEK(dirección%)

donde: es la posición de memoria relativa a la dirección del segmento actual, establecida por DEF SEG ( dirección es un entero: 0-65.535) valor es el byte (0-255) que se lee de la memoria.
dirección

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:
' Determina los puertos paralelo instalados en el PC y sus direcciones DEF SEG = 0 FOR puerto% = 0 TO 2 1 (LPT2), 2 (LPT3) ' selecciona el segmento de memoria 0 ' número de puerto paralelo: 0 (LPT1),

' dirección del puerto dir% = PEEK(&H408 + puerto% * 2) + 256 * PEEK(&H408 + puerto% * 2 + 1) IF dir% = 0 THEN PRINT "No hay puerto asignado a LPT"; puerto% + 1 ELSE PRINT "La direcci¢n de LPT"; puerto% + 1; " es "; dir% END IF NEXT puerto% END

Escritura en la memoria
Para almacenar un dato en la posición de memoria designada por segmento:offset , QBasic proporciona la función POKE. Ésta almacena un carácter (1 byte). La sintaxis de la función es:
POKE dirección%, valor%

donde: es la posición de memoria r elativa a la dirección del segmento actual, establecida por DEF SEG ( dirección es un entero: 0-65.535) valor es el byte (0-255) que se desea escribir en la dirección de memoria especificada.
dirección

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:
' Cambia el estado de Bloq Mayús

DEF SEG = 0 Estado% = PEEK(&H417) ' Lee el estado del tecl ado POKE &H417, (Estado% XOR &H40) ' Cambia el estado del Bloq Mayús, bit 6 END

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

Aspecto del código
Obsérvese el siguiente código:
DIM cadena AS STRING, i AS INTEGER PRINT "Introduce una cadena:"; : INPUT "", cadena$: FOR i%=1 TO LEN(cadena) PRINT MID$(cadena, i%, 1) NEXT i% END

Ahora compárese con este otro:
' Muestra uno a uno los caracteres de una cadena DIM cadena AS STRING, i AS INTEGERR PRINT "Introduce una cadena:"; INPUT "", cadena FOR i=1 TO LEN(cadena) PRINT MID$(cadena, i, 1) NEXT i END

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. Aquí está un ejemplo de un programa mal comentado:
' Empiezo el programa DIM cadena AS STRING, i AS INTEGER llamada cadena y otra llamada i ' declaro una variable

PRINT "Introduce una cadena: " ' Imprimo el mensaje 'Introduce una cadena' INPUT "", cadena ' Pregunto por el valor de cadena FOR i=1 TO LEN(cadena) ' Hago un bucle repetitivo PRINT MID$(cadena, i, 1) NEXT i ' Cierro el bucle END ' Termino el programa

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 DIM cadena AS STRING, i as INTEGER almacenará el texto introducido de caracteres de <cadena> PRINT "Introduce una cadena: " INPUT "", cadena FOR i=1 TO LEN(cadena) hasta la longitud de la cadena PRINT MID$(cadena, i, 1) NEXT i END ' Muestra cada carácter ' En <cadena> se ' <i> será el contador

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:
DIM i%, j%, k% DIM x1#, x2#, x3#, x4# DIM a$, b$ ' ... muchas más variables

¿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:
DIM cuenta.x%, cuenta.y%, cuenta.z% z DIM x.minimo#, x.maximo# DIM y.minimo#, y.maximo# rectángulo DIM tecla.inicio$, tecla.fin$ comienzo y fin ' ... etc ' Esquinas del ' Pulsaciones de ' Nº de posiciones x, y,

2002 Víctor R. González

You're Reading a Free Preview

Descarga
scribd
/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->