Curso de programación en Visual Basic - Funciones de conversión 3

Curso básico de programación en Visual Basic

Lección 3

Funciones de conversión - Declaración de constantes

Realizamos programas para la gestión de empresas. Empresas medianas y pequeñas. Programas de contabilidad, cartera de pedidos clientes proveedores, facturación control de albaranes, tesorería cartera de cobros y pagos y estadísticas.
Nuestro agradecimiento a todos los que por unas causas o por otras visitan nuestra web. Gestión de empresas PYMES. Curso de programación de Visual Basic.

Bien, después de un mes y pico, seguimos con la tercera entrega del curso "super-básico" de programación con Visual Basic.

Esta entrega la voy empezar con recomendaciones e instrucciones del buen hacer en Visual Basic, espero que sigas algunas, preferiblemente todas, estas normas.

Ya has visto cómo maneja el Visual Basic las variables, si a esta "libertad" (aunque más bien es libertinaje), le añadimos que no nos obliga a nada, es decir el VB nos está diciendo: "puedes usar las variables para lo que quieras, cómo quieras (o casi) y cuando quieras"
Y esto en principio podría parecer una buena cosa, pero realmente es un mal hábito, que muchos de los que venís del BASIC, ya tenéis formado y creo que ahora sería un buen momento para empezar a cambiar.

Lo primero que debes hacer es ir al menú Herramientas (Tools) y en Opciones (Options) marca la casilla que indica "Requerir declaración de variables" (Require Variable Declaration), esto añadirá a cada nuevo módulo (FRM, BAS o CLS) la siguiente instrucción: Option Explicit, de esta forma tendrás la obligación de declarar cada una de las variables que uses en el programa. Y tu preguntarás: ¿Para que obligar a que se declaren las variables? La respuesta es bien sencilla: para que las declares... (algunas veces me asombro de la lógica tan aplastante de mis comentarios)
Bromas aparte, es recomendable que declares las variables que vayas a usar y te diría más: no sólo es bueno declarar las variables, sino que mejor aún es declararlas del tipo adecuado.
Ya vimos que hay diferentes tipos de variables, no sólo de tipos genéricos como podrían ser para almacenar caracteres y números, sino que dentro de las numéricas hay varios tipos, y cada uno de ellos tiene una razón de ser.
En mis tiempos del BASIC normalito, es decir del MS-DOS, no existía esta obligación de declarar "forzosamente" las variables y cuando estabas escribiendo un programa (proyecto que lo llaman ahora), grande, acababas "inevitablemente" usando más variables de la cuenta porque ya no recordabas si la variable "i" o "j" estaba siendo usada a nivel global o no... (yo es que con el despiste que gasto, me veía creando las variables "ii", "j2", etc., para no "meter la pata") y esto no era lo peor, al fin y al cabo lo único que ocurría era que estaba "desperdiciando" memoria, por no tener un control de las variables que estaba usando; lo malo era que se podían escribir erróneamente los nombres de las variables de forma que al final, el programa no funcionaba bien porque al escribir un nombre de variable, habíamos cambiado el nombre... era frustrante y algunas veces te volvías loco buscando el fallo...
La ventaja de usar el Option Explicit, es que si escribes mal una variable, el VB te avisa... bueno, algunas veces te avisa, sobre todo cuando se encuentra con la variable "mal escrita".

Aquí viene la segunda recomendación del día: cuando ejecutes un programa, hazlo con Control+F5, de esta forma se hace una compilación completa y "más o menos" exhaustiva del código, avisándote cuando hay algo que no "cuadra", con el VB3 no había problemas, ya que siempre se hacía la compilación completa, pero desde el VB4 se puede pulsar F5 y hasta que no llega al procedimiento actual, no comprueba si todo lo que hay en él está correcto.
Así que para "curarte en salud" procura hacer la compilación completa

La tercera recomendación no es obligatoria, siempre que sigas la que voy a dar después, esta es una norma que también he usado desde mis tiempos de MS-DOS (aunque reconozco que últimamente no la pongo en práctica, ya que hago lo que después comentaré en la cuarta recomendación).
En todos los módulos, antes sólo eran BAS, ponía al principio la siguiente línea:
DEFINT A-Z
de esta forma le indicaba al BASIC que mi intención era usar todas las variables del tipo Integer (entero), (realmente después usaba del tipo que me daba la gana, pero mi primera intención era no complicarme la vida con la mayoría de las variables), cuando quería usar una variable diferente de Integer, le indicaba "explícitamente" de que tipo era y así me obliga a usar la mayoría de ellas de este tipo que a la larga es o era el más usado, ya que para hacer bucles (ya te explicaré en un ratillo que es eso de los bucles y cómo hacerlos en VB) y otros cálculos "normales", era más que suficiente y en la mayoría de los casos: más rápido.

En Basic, y por supuesto todavía en Visual Basic, aunque cada vez va a menos, se puede indicar el tipo de una variable de varias formas, al declararlas con Dim, vimos que se hacía de la siguiente forma:

Dim unNumero As Integer
Dim unNumeroLargo As Long
Dim otroNumero As Single
Dim masNumeros As Double
Dim unNombre As String
Dim multiUso As Variant

Cada una de estas variables es de un tipo distinto, las cuatro primeras numéricas, la quinta para almacenar cadenas de caracteres y la última del tipo por defecto del VB: Variant que como su nombre indica (aunque en inglés), es Variante y puede almacenar prácticamente cualquier cosa, objetos incluidos, (ya veremos los objetos en otra ocasión). Lo del tipo por defecto, es siempre que no se haya especificado un tipo determinado para todas las variables, por ejemplo usando el DEFINT A-Z, el tipo por defecto ya no es Variant, sino Integer.
Al grano, "quesnoche", a lo que iba era que además de declarar las variables de esta forma, también se puede hacer de de esta otra:

Dim unNumero%
Dim unNumeroLargo&
Dim otroNumero!
Dim masNumeros#
Dim unNombre$

En el caso de Variant no existe un caracter especial para indicar que es de ese tipo, así que cuando quieras usar una variable Variant, tendrás que declararla como en el primer ejemplo.
Aún queda otro carácter para otro tipo de datos numérico, el tipo Currency que se puede declarar con @. Este tipo ocupa 8 bytes y permite guardar números de tipo moneda, es decir números no enteros, pero con un número determinado y fijo de decimales, ahora no recuerdo, pero en la ayuda o en los manuales podrás ver la "retaila" de números que cada tipo admite.

Para terminar con las recomendaciones de hoy, voy a indicarte algo que debes tener en cuenta cuando declaras variables y que aún los más expertos caen en la trampa.

Además de declarar las variables con Dim, poniendo cada declaración en una línea, cosa que por otro lado queda bastante claro y es como suelo hacerlo, aunque últimamente estoy volviendo a coger malos hábitos... ¿será la edad?
También se pueden declarar más de una variable con un mismo DIM, vamos a verlo con un ejemplo:
Dim Numero As Integer, NumeroLargo As Long, otroNum As Single, Nombre As String, Numerazo As Double
por supuesto también valdría de esta otra forma:
Dim Numero%, NumeroLargo&, otroNum!, Nombre$, Numerazo#
Y si me apuras, también de esta otra:
Dim Numero%, NumeroLargo As Long, otroNum As Single, Nombre$, Numerazo#

Pero sea como fuere, en todos los ejemplos se ha especificado el tipo que queremos asignar.
Por supuesto también podremos declarar variables de esta forma:
Dim unaVariable, otraVariable, terceraVariable
Pero, surge esta pregunta ¿de que tipo son estas tres variables? (al menos se espera que te surja...)
La respuesta es bien sencilla, si se ha entendido toda la "retahila" que te he soltado anteriormente:
Serán del tipo Variant o del especificado con el DEFINT A-Z (es decir Integer)
Voy a suponer que la tercera recomendación no la estás poniendo en práctica, por tanto serían del tipo Variant.

Pero fíjate que podrías caer en el error, sobre todo si has programado algo en C, de pensar que esta línea:
Dim Numero, otroNumeroInt, elTercero As Integer
o esta otra:
Dim Numero As Integer, otroNumeroInt, elTercero
están declarando tres números Integer y no es así, lo que se está declarando sería, en el primer caso:
Numero y otroNumeroInt como Variant y elTercero como entero.
en el segundo caso sólo Numero sería del tipo entero y las otras dos variables del tipo Variant.

Sería "ideal" que fuese como aparenta, pero el VB no hace estas "virguerías", ni incluso en la versión 5.

Por tanto, cuando declares variables, fíjate bien de que tipo son las que estás declarando, para no llevarte sorpresas, sobre todo con los redondeos y errores de desbordamiento...
Un desbordamiento se produce cuando asignamos a un número un valor mayor del que está capacitado para almacenar, así si un entero sólo acepta valores de +/- 32767 (realmente acepta hasta -32768), al asignarle un valor de 40000, nos dirá que "tururú" y dará error.

En cuanto a que tipo de variable usar en cada caso, tendrás que tener en cuenta que quieres hacer. Normalmente en los bucles se suelen usar variables enteras, bien Integer, si sabemos que no nos vamos a pasar de 32767, bien Long Integer que puede almacenar un valor de dos mil y pico millones... (¡quien los tuviera, aunque fuese en calderilla!)

Vamos a ver un ejemplo (al fin algo de código se escucha entre el público...), con este código podrás comprobar la velocidad de los bucles con los distintos tipos de variables y así poder comprobar cual es la más adecuada.
Crea un nuevo proyecto y asigna unos cuantos Labels (6 en total) y un botón.
Cuando ejecutes este programilla, puedes ir tranquilamente a tomar café, porque se tomará su tiempo...
En teoría nos mostrará el tiempo que emplea en hacer unos bucles con tipos diferentes de datos. Para que sea fiable, deberás especificar unos valores altos, ya que con números pequeños no es demasiado fiable, e incluso con números altos tampoco... la cosa era poner algo de código para "rematar" el capítulo de hoy...
En la próxima entrega explicaré las instrucciones que se han usado y en algunos casos, explicaré hasta el por qué de usarlas.

O sea esto es lo que se dice un programa inútil que además de consumir recursos del sistema y hacernos perder el tiempo, no vale para nada... (es que después de probarlo, me he dado cuenta de que o todos los formatos son prácticamente igual de rápidos o yo he estado "engañado" durante todo este tiempo...)

Option Explicit

Private Sub Command1_Click()
    Dim nInt As Integer
    Dim nLng As Long
    Dim nSng As Single
    Dim nDob As Double
    Dim nCur As Currency
    Dim nVar As Variant

    Dim timer1#, timer2 As Double
    Const minBucle = 1, maxBucle = 10

    Command1.Caption = "Calculando..."
    timer1 = Timer
    For nInt = minBucle To maxBucle
        Contar CInt(nInt), Label1
    Next
    timer2 = CDbl(Timer - timer1)
    Label1 = "Duración con Integer: " & timer2
    DoEvents

    timer1 = Timer
    For nLng = minBucle To maxBucle
        Contar CInt(nLng), Label2
    Next
    timer2 = CDbl(Timer - timer1)
    Label2 = "Duración con Long: " & timer2
    DoEvents

    timer1 = Timer
    For nSng = minBucle To maxBucle
        Contar CInt(nSng), Label3
    Next
    timer2 = CDbl(Timer - timer1)
    Label3 = "Duración con Single: " & timer2
    DoEvents

    timer1 = Timer
    For nDob = minBucle To maxBucle
        Contar CInt(nDob), Label4
    Next
    timer2 = CDbl(Timer - timer1)
    Label4 = "Duración con Double: " & timer2
    DoEvents

    timer1 = Timer
    For nCur = minBucle To maxBucle
        Contar CInt(nCur), Label5
    Next
    timer2 = CDbl(Timer - timer1)
    Label5 = "Duración con Currency: " & timer2
    DoEvents

    timer1 = Timer
    For nVar = minBucle To maxBucle
        Contar CInt(nVar), Label6
    Next
    timer2 = CDbl(Timer - timer1)
    Label6 = "Duración con Variant: " & timer2
    DoEvents
    Command1.Caption = "Calcular"
End Sub

Private Sub Contar(valor As Integer, etiqueta As Control)
    Dim i As Integer
    Dim unDoble As Double
    Const elMaximo = 1000&

    For i = 1 To elMaximo
        unDoble = unDoble + 1
        etiqueta.Caption = valor * elMaximo + unDoble
        DoEvents
    Next
End Sub