SABERMASJUSTODARACT
SABERMASJUSTODARACT Por una Facultad de provecho a la comunidad

Qbasic Olor a pestañas quemadas

Una vez que ya hemos hecho nuestro primer programita, y vemos que funciona, entonces profundizaremos un poco mas en el conocimiento teorico, que nos servirá para todos los idiomas de programación.
La antigua manera de programar, se llamaba programación serial o secuencial, en este tipo de programación, el código se armaba línea tras línea a medida que se iba ejecutando, y si había que seleccionar, se hacían saltos de línea, medianotes ordenes como GO TO (Nro de línea) o etiqueta
SI vemos algunos códigos,  todavía se estila usar Nros de línea en algunos códigos, pero solo para tener una referencia visual al mencionar una parte del mismo
La programación modular, divide el código en partes que hacen un determinado trabajo, o función. Reciben el nombre de funciones, o procedimientos según el caso.
http://es.wikipedia.org/wiki/Programación_modular

Las funciones, casi siempre reciben valores como parámetros, y devuelven también algún valor como resultado, en cambio los procedimientos por lo general, usan las variables del entorno con sus valores, y ejecutan alguna tarea especifica (imprimir, mostrar etc.) Estos conceptos estan bastante discutidos, pero en general son aplicables a todos los idiomas de programacion, las funciones y los procedimientos, pertenecen al grupo de las rutinas o subrutinas. (el programa deja de ejecutarse siguiendo su secuencia para hacer una determinada subrutina).

Otro concepto es el de las macros, que son partes de código que se incorporan al código principal al ser invocadas

http://es.wikipedia.org/wiki/Subrutina

 

En el idioma que estamos usando, el QuickBasic, podemos usar estas rutinas, para lo cual nos vamos a edicion nueva sub y le ponemos un nombre,  esta subrutina tendrá su propio codigo y podemos llamarla desde el codigo principal cuando querramos y cuantas veces lo querramos. Nos aparecera como Sub (nombre) y al finalizar su código End Sub

 

Tambien podemos uar funciones mediante la orden FUNCTION (nombre) lista de parámetros que termina con el END FUNCTION; para devolver un valor ponemos el (nombre) = a lo que devolverá;  una linea antes de terminar la función

 

La POO que es el nombre que recibe la Programacion Orientada a Objetos, usa estos elementos, ademas de otros que permiten cumplir sus requisitos, asi que haremos uso de estos elementos para irnos acostumbrando cuando avancemos con otros idiomas que trabajan con objetos.

 

Ahora dare un breve concepto del tema para los que no quieren quedarse con las duda. Un Objeto, es una instancia de una Clase

Una Clase, es una declaración de un conjunto de datos, sus funciones, sus rutinas que tiene capacidad para hacer determinadas cosas y responde a ciertas otras, lo que recibe el nombre de propiedades,  de atributos, y métodos

http://es.wikipedia.org/wiki/Clase_(informática)  

Las propiedades se refieren a las características que puede asumir (Ej., en el caso de una ventana de datos, alto, ancho, color, tipo de letra, imagen de fondo etc.), mientras que los atributos son los como  parámetros que puede recibir para hacer  determinadas tareas que se llaman métodos.

 

Si Dios quiere, cuando entremos al Visual Basic, estos conceptos quedarán más claros, al relacionarlo con los objetos visuales de ese idioma, que es una “evolución” del Qbasic

 

Después de esta dosis de teoría, que les abrá costado a mas de uno que se le quemen las pestañas, seguimos con los códigos de Quick Basic

 

Abriremos MULTITAB.BAS (esta entre los codigos de ejemplo que bajarás cuando bajes el compilador)

 

DIM i%, j%, k%, f%

CLS

k% = 1

f% = 1

FOR i% = 1 TO 10

FOR j% = 1 TO 10

LOCATE f%, k%

PRINT USING "## * ## = ###"; i%; j%; i% * j%

 

f% = f% + 1

IF f% = 11 THEN f% = f% + 1

IF f% > 21 THEN

f% = 1

k% = k% + 15

END IF

 

NEXT j%

NEXT i%

 

Acá tenemos como diferencia, el uso del formato, que en Qbasic se pone como PRINT USING (” formato “); variables y formato es una cadena de caracteres que podemos seleccionar usando la referencia de: Ayuda, Índice, Print Using,  <especificadores de formato>

 

             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.                         el 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.           ║ **    Llena espacios adelante con *

^^^^  Imprime con formato exponencial.      ║ **$   Combina ** y $$.

 

             Caracteres que dan formato a una expresión de cadena

 &    Imprime la cadena completa.               Imprime los primeros n

 !    Imprime sólo el primer carácter                  caracteres, donde n es el

      de la cadena.                                                número de espacios entre

                                                                           barras + 2. 

 
         
Caracteres utilizados para imprimir caracteres literales

 _    Imprime el carácter de formato                  Cualquier carácter que no

      siguiente como literal.                                  esté en la tabla será

                                                                           impreso como literal.

 

Esto es muy útil para presentar ordenadamente datos que pueden tener variaciones en su tamaño, y lo mismo a la hora de imprimir

Esto seria para el detalle de una factura

 

PRINT "║ Cant.│        Detalle del Artículo      │ Precio │ Subtotal ║"      

PRINT "║______│__________________________________│________│__________║"

PRINT USING "║  ### │                                │ ###.## │ #####.##║ “;C1!; Det1$; Prec1!; Stot1!

PRINT "║------│----------------------------------│--------│----------║"

PRINT USING "║  ### │                                │ ###.## │ #####.## ║"; C2!; Det2$; Prec2!; Stot2!

PRINT "║------│----------------------------------│--------│----------║"

PRINT USING "║  ### │                                │ ###.## │ #####.## ║"; C3!; Det3$; Prec3!; Stot3!

PRINT "║------│----------------------------------│--------│----------║"

PRINT USING "║  ### │                                │ ###.## │ #####.## ║"; C4!; Det4$; Prec4!; Stot4!

PRINT "║------│----------------------------------│--------│----------║"

PRINT USING "║  ### │                                │ ###.## │ #####.## ║"; C5!; Det5$; Prec5!; Stot5!

PRINT "║------│----------------------------------│--------│----------║"

PRINT USING "║  ### │                                │ ###.## │ #####.## ║"; C6!; Det6$; Prec6!; Stot6!

PRINT "║------│----------------------------------│--------│----------║"

PRINT "║                                          ╔═════════════════╗║"

PRINT "║                               TOTAL :■■>"; USING " ║        #####.## ║║"; Stot1! + Stot2! + Stot3! + Stot4! + Stot5! + Stot6!                                                    

PRINT "║                                          ╚═════════════════╝║"

 

GOSUB PRINTPIE        ‘//en esta linea llamo a un procedimiento que muestra el pie de la factura

 

PRINTPIE:                                                                     

      PRINT "║cuit:20-11782071-9     Ingr.Bru:                             ║"

      PRINT "║Confeccionada por computadora; sin valor fiscal              ║"

      PRINT "╚═════════════════════════════════════════════════════════════╝"

      PRINT ""                                                                    

      PRINT ""                                                                     

RETURN

'=============================================================================

 

Vemos el uso del RETURN que sirve en este caso, para seguir el programa a partir de donde el procedimiento fue llamado

 

 

Ahora el manejo de archivos, para eso abrimos BASEDAT.BAS donde tenemos el siguiente código

Vemos el uso del DO (hacer) que termínan en LOOP WHILE (condición) algo así como: Repetir Mientras la condición se cumpla

Mas abajo vemos DO WHILE NOT EOF(1) Hacer mientras no sea fin del archivo 1 que termina en LOOP

 

    CLS                                                                      

    OPEN "LISTA" FOR OUTPUT AS #1                                            

    DO                                                                        

        INPUT "   NOMBRE:       ", Nombre$  'Lee datos desde el teclado.     

        INPUT "   EDAD:         ", Edad%                                      

        INPUT "   PESO:         ", Pesok#                                     

                                                                              

        WRITE #1, Nombre$, Edad%, Pesok#                                      

        INPUT "¿Desea ingresar otros datos"; R$                              

    LOOP WHILE UCASE$(R$) = "S"                                               

    CLOSE #1                                                                  

    'Mostrar el archivo en la pantalla.                                       

    OPEN "LISTA" FOR INPUT AS #1                                              

    CLS                                                                       

    PRINT "Datos en el archivo:": PRINT                                       

    DO WHILE NOT EOF(1)                                                       

        INPUT #1, name$, year%, peso# 'Leer datos del archivo.                

        PRINT name$, year%, peso#           'Imprimir los datos en la pantalla

    LOOP                                                                      

    CLOSE #1                                                                  

    KILL "LISTA"      ‘// Esta orden podemos eliminarla para que nos quede el archivo en el disco, y poder verlo                                                        

 

De esta manera, podemos hacer una sucesion de registros similares, y para saber en que posicion esta, solo basta agregar un contador en la presentacion

    Cont%=0

     DO WHILE NOT EOF(1)                                                       

        INPUT #1, name$, year%, peso# 'Leer datos del archivo.               

        PRINT cont%, name$, year%, peso#           'Imprimir los datos en la pantalla

        Cont%=Cont% +1

LOOP                                                                      

 

Otra forma, seria al grabar el registro, agregarle un numero de índice, pero debemos asegurarnos, que cuando cerramos y volvemos a abrir el programa, el Nro de índice continué al ultimo, para lo cual hay que hacer primero una lectura buscando ese índice, y luego abrir el archivo para escribirlo

Cuando se requiere más precisión en el manejo de datos, se usa un tipo de dato personal, que no es más que un conjunto de datos definidos como un dato complejo, (asemejándose a una clase y a objetos). Para esto usamos TYPE

 

Define un tipo de datos que contiene uno o más elementos.

TYPE tipousuario

  elemento AS tipo

  [elemento AS tipo]

 

END TYPE

 

    ■ tipousuario    El nombre del tipo de datos que será definido. El

                     nombre puede tener hasta 40 caracteres y debe comenzar

                     con una letra. Los caracteres válidos son A-Z, 0-9 y el

                     punto (.). No se pueden usar letras acentuadas ni la ñ.

    ■ elemento       Un elemento del tipo de datos definido por el usuario.

    ■ tipo           El tipo de datos del elemento (INTEGER, LONG, SINGLE,

                     DOUBLE, STRING o un tipo de datos definido por el

                     usuario).

 

Ejemplo:

    TYPE Cartas

        Palo AS STRING * 9

        Valor AS INTEGER

    END TYPE

    DIM Juego(1 TO 52) AS Carta

    Juego(1).Palo = "Bastos"

    Juego(1).Valor = 2

    PRINT Juego(1).Palo, Juego(1).Valor

 

La ventaja es que al definir un tipo de dato de usuario. Nos aseguramos que el contenido del mismo, no se mezclara con otros datos y que podemos crear un vector de esos datos y usar el indice del vector para localizar un registro en forma individual, sin tener que andar pasando por todos

Un vector, es un arreglo de datos del mismo tipo, diferenciados por un indice,

Cuando el arreglo tiene una sola dimension, tiene un solo indice y se llama comunmente vector o matriz de una dimension

Cuando el arreglo tiene mas de una dimensión, se llama comunmente matriz y tiene tantos indices como dimensiones

 

Luego el procedimiento quedaria asi

1)      crear tipo de dato de usuario  (semejante a la clase )

2)      crear un vector de esos datos (semejante a crear un grupo de instancias u objetos)

3)      Amacenar en el dico duro y trabajar en el programa con ese vector

  Los códigos y los programas están a disposición del que quiera, sin ir contra los derechos de autoria y de propiedad vigentes.
Use el formularo de contacto para que podamos ver como intercambiar la documentación-
_ Gracias.-

Seguir-->

 
Este sitio web fue creado de forma gratuita con PaginaWebGratis.es. ¿Quieres también tu sitio web propio?
Registrarse gratis