Tipos
definidos por el usuario
|
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.
|
¿Cuanto tiempo, verdad? Pues ya
ves que no desisto, te costará librarte de mis cursos, jé, jé.
Lo primero es lo primero, así que,
en este link tienes las
soluciones de los ejercicios de la décima entrega.
Y ya vamos al tema de hoy:
Nuestras propias variables
Ya has visto prácticamente la
totalidad de tipos de variables que Visual Basic soporta, también
has visto cómo agrupar variables para crear arrays.
Ahora voy a explicar cómo puedes crear tus propias variables.
Realmente no es crear una variable, sino un tipo de variable
especial en el que se pueden agrupar variables de distintos tipos;
es lo que en otros lenguajes se llaman estructuras.
En Basic son tipos definidos por el usuario (TDU o UDT User
Defined Type, que dirían los English-speaken esos)
En un UDT podemos incluir variables
que estén relacionadas, realmente puedes incluir casi todo lo que
se te ocurra, pero no tendría mucho sentido incluir cosas que no
tengan relación, vamos, digo yo.
Imagínate que quieres hacer una utilidad que dibuje puntos en la
pantalla y necesitas tener la posición de, digamos 1000 puntos, una
solución sería declarar dos arrays, una para la posición de la
fila y otra para la columna de cada punto:
Dim PuntoY(1000) As Integer, PuntoX(1000) As Integer
Cuando necesitemos dibujar el punto
N en X,Y, haríamos algo como
esto:
PuntoY(N) = y: PuntoX(N) = x
Y si lo que pretendemos es
averiguar la posición del punto A, lo sabríamos
así:
y = PuntoY(A): x = PuntoX(A)
Simplemente estaríamos usando un
array para la fila (PuntoY) y otro para la columna
(PuntoX), para simplificar todo esto, podemos crear
un tipo en el cual tendríamos almacenado la posición de cada
punto, para ello, hay que hacer una declaración de la siguiente
forma:
Type tPunto
X As Integer
Y As Integer
End Type
cada vez que necesitemos una
variable de este Nuevo tipo, tendremos que
declararla como cualquier otra variable:
Dim unPunto As tPunto
Mu bonito, pero ¿cómo asignamos
los valores?
De una forma muy especial, para acceder a cada uno de los datos que
puede almacenar nuestra variable tendremos que especificar el nombre
de la variable, un punto y a continuación la variable interna que
nos interese...
Veámoslo:
unPunto.X = 100
unPunto.Y = 20
Para saber el valor guardado en la X
de nuestra variable lo sabríamos así: columna
= unPunto.X
Siempre usando el punto después de
la variable interna, esto puedes encontrártelo en algunos libros o
manuales, usando la expresión: "para acceder a un miembro de
una estructura de datos definida por el usuario..." pero el
significado, al final, es el mismo...
Bien, ahora si queremos crear un
array para guardar los mil puntos esos a los que me refería al
principio:
Dim Puntos(1000) As tPunto
Para almacenar la posición del
punto N:
Puntos(N).X = x: Puntos(N).Y = y
Y seguro que ahora sabrás como
obtener la posición del punto A.
Pero también podemos almacenar el punto actual en una variable
normal de este tipo y asignar ese valor a un elemento del array:
Dim PuntoActual As tPunto
PuntoActual.X = un_valor: PuntoActual.Y = otro_valor
Puntos(N) = PuntoActual
Distintos tipos de
variables en un tipo definido
Los tipos definidos, no sólo
sirven para "mezclar" variables del mismo tipo, sino que
puedes tener variables de varios tipos, incluso variables de tipos
definidos... Sí, un verdadero lío...
Espero que después de leerte esta
entrega y con los ejemplos que veremos en las próximas, (cuando le
toque el turno al manejo de ficheros), se te aclararán las dudas.
Otro ejemplo clásico
Este es uno de los más usados para
este tipo especial de variables y la verdad es que es también el
más usado, enseguida sabrás porqué.
| Situación: |
Tener los datos de todos los
colegas y otros que no lo son tanto. |
| Datos: |
Nombre y apellidos,
dirección, teléfono fijo, teléfono móvil, dirección
e-mail, URL y cualquier otra cosa que se te ocurra. |
| El
Tipo: |
Para un caso como este,
(simplificando un poco), podríamos usar este tipo definido:
Type tColega
Nombre As String
Apellidos As String
Direccion As String
Poblacion As String
Edad As Integer
VecesQueLeHeMandadoUnMailYNoContesta As Long 'Esto por si soy yo 8-)
End Type
|
Fíjate en el último
"campo" del tipo, es una chorrada (aunque más de uno no
pensará así), pero es para que veas que se pueden usar nombres de
variables "super-largos", ¡hasta 40 caracteres! Es decir,
que si te gustó Mary Poppins, podrías tener una variable que se
llamara: MeGustaSupercalifragilisticoespialidoso.
Ya en serio, no es conveniente el
uso de nombres tan largos, no hagas caso de la propaganda esa que te
dicen que es mejor usar nombres descriptivos, ya que ¡¡¡es una
lata tener que escribirlos!!!
En caso de que te de el "punto" de escribir nombres
largos, puedes hacerlo, incluso puedes usar más de 40 letras, sólo
que las primeras 40 tienen significado... es decir que si al
supercali... ese le añades más letras, sólo reconocerá las 40
primeras.
Por ejemplo:
SupercalifragilisticoespialidosoChitiChitiBangBangVolando
SupercalifragilisticoespialidosoChitiChitiBangBangParado
Para el VB será la variables (un momento que cuente las letras):
SupercalifragilisticoespialidosoChitiChi
De todas formas sigo pensando que
es algo tedioso eso de escribir nombres tan largos...
Otro caso de las variables, creo
que este aún no lo hemos visto, es este:
Cuando vayamos a usar este tipo de variables para guardar los datos
en ficheros (dentro de un par de entregas ya los estarás usando),
es conveniente "definir" la longitud máxima de las
cadenas de caracteres, por ejemplo:
Reservar 20 caracteres para el nombre ó 50 para la dirección, en
este caso la declaración de las variables se harían así:
Dim Nombre As String * 20
Dim Direccion As String * 50
Y si están en un tipo definido:
Type tFijos
Nombre As String * 20
Direccion As String * 50
End Type
La ventaja de hacerlo así: al
tener una longitud fija, podemos acceder a cualquier registro
haciendo unos pequeños cálculos... aunque de esto se encarga de
forma automática el propio Basic y como he dicho antes: lo veremos más
después.
Vamos con algunos ejemplos.
Ya tenemos definido el tipo tColega,
si queremos usarlo sólo hay que DIMensionar una
variable para que sea de ese tipo:
Dim unColega As tColega
Y para guardar el nombre de ese
colega:
unColega.Nombre = "Pepito"
Con los demás campos se haría
igual.
Ahora, se nos presenta la
situación de que tenemos, por poner un ejemplo, 50 colegas; así
que vamos a reservar espacio para todos ellos:
Dim misColegas(1 To 50) As tColega
Para almacenar el nombre del colega
número uno:
misColegas(1).Nombre = "Maria de las Mercedes"
Para mostrarlos, simplemente
hacemos un bucle que recorra este array y asunto concluido:
For i = 1 To 50
Print misColegas(i).Nombre, misColegas(i).Apellidos, ...etc.
Next
Que quieres imprimir de forma
aleatoria uno de los 50 nombres, digamos para gastarle una
inocentada, pues haces esto:
Print misColegas(Int(Rnd * 50) + 1).Nombre
Ya sabes, si no lo sabias, ahora lo
sabrás, que el índice de un array, el numérico ese que se pone
dentro de los paréntesis, puede ser cualquier expresión numérica,
que de como resultado un valor que esté dentro de los límites de
la cantidad de variables que tiene ese array... Sí, es que si ese
valor no está "dentro" de los elementos que tienes
dimensionados, te "regañará" el VB diciéndote: Index
Out of Range (o sea: T'as pasao, colega)
Un alto en el camino.
Toma papel y lápiz, porque esto es
una nueva instrucción.
Ya has visto en el ejemplo de
imprimir los 50 nombres, que cada vez que accedes a uno de los
campos (o variables internas) del tipo definido, tienes que usar el
nombre de la variable el punto y después el campo.
Pues a partir del VB4, este asunto se ha simplificado y no sólo
para los tipos definidos, ya verás, en un futuro no muy lejano,
calculo que antes del año 2010, que se puede usar en todas las
situaciones en las que "algo" tenga otros
"algos" dentro de él y haya que acceder por medio del
punto... Si no lo captas, no te preocupes, ya te enterarás bien...
La palabra mágica es: WITH
No te voy a hacer una presentación
formal de esta instrucción, ya tienes el manual del VB o la ayuda y
allí seguro que estará bien "definida", vamos a ver
cómo usarla en el ejemplo este que nos traemos entre manos:
For i = 1 To 50
With misColegas(i)
Print .Nombre, .Apellidos, .Direccion, ...etc.
End With
Next
¡Ves que fácil! Hasta he puesto
otro de los campos...
De esta forma no tienes que repetir el nombre de la variable, el
Visual ya sabe que te estás refiriendo a misColegas(i),
porque esa es la variable que has usado después de With.
Esto mismo se puede usar con
cualquier objeto del VB, los tipos definidos no son objetos, pero se
parecen, en unas cuantas de miles de entregas más, te enterarás
del porqué...
Por ejemplo para asignar varias de
las propiedades de un TextBox llamado Text1:
With Text1
.SelStart = 0
.SelLength = Len(.Text)
End With
Este mismo ejemplo sin With,
como lo tendrían que hacer con el VB3, sería
esto:
Text1.SelStart = 0
Text1.SelLength = Len(Text1.Text)
Como comprobarás, está más claro
si se usa el With
Además, se pueden anidar varios
Withs... unos dentro de otros, pero siempre el PUNTO hará
referencia al último que se ha puesto, esta situación ni la voy a
"ejemplificar" ya que cuando le toque el turno, le
tocará...
Bueno, vamos a dejarlo por ahora;
en la siguiente parte de esta entrega, usaremos todo esto en un
pequeño programa en el cual se introducirán los datos y todas esas
cosas... Pero eso será mañana (hoy realmente, pero más tarde)
En seguida nos vemos.
