Tanto los vectores como las matrices son un conjunto de
datos de un mismo tipo, para muchos al escribir sobre matrices se refieren
tanto a matrices de 2 dimensiones como de una dimensión. Aunque sea lo mismo
prefiero decir que un vector tiene una dimensión y una matriz más de una
dimensión.
Existen
diferentes formas de declarar variables de vector, por ejemplo:
Dim a(4) As String
a(0)=”indice cero”
a(1)=”indice
uno”
ó
Ahora si
lo que queremos es un vector numérico será:
Dim
VectorA() As Short = {6, 7}
Y si es
de dos dimensiones será:
Dim
Matriz(10,20) as Single
Aunque
también pueden declararse de las siguientes maneras:
Vectores
Dim BA() As Byte = New Byte() {}
Dim BA() As Byte = New Byte() {0,1,2}
Dim BA() As Byte = New Byte(2) {0,1,2}
Matrices
Dim JB()() As Byte = {New Byte() {}, New Byte()
{}}
Dim JB()() As Byte = {New Byte(1) {}, New Byte(1)
{}}
Dim JB()() As Byte = {New Byte() {5, 6}, New Byte()
{7, 8}}
Dim S(,) As Short = New Short(,) {}
Dim S(,) As Short = New Short(1, 1) {}
Dim S(,) As Short = New Short(,) {{5, 6}, {7, 8}}
Ahora realizaremos el siguiente ejemplo que lo que se
busca es mostrar algunas propiedades de los arrays.
Option Explicit
On
Option Strict On
Module Module1
Sub Main()
Dim
VectorA() As Integer
= {3, 4, 1, 2, 5, 0, 0, 0, 0}
Dim
VectorB() As Integer
= {8, 7, 6, 9}, i, j As Integer
Dim ref() As Integer
Dim
Dimension As Integer
If TypeOf (VectorA) Is
Array Then
Console.WriteLine("______________________________")
Console.WriteLine("El primer arreglo es VectorA")
For i = 0 To
VectorA.GetLength(0) - 1
Console.WriteLine("Indice
{0}={1}", i, VectorA(i))
Next
Console.WriteLine("El
segundo arreglo es VectorB")
For i = 0 To
VectorB.GetLength(0) - 1
Console.WriteLine("Indice
{0}={1}", i, VectorB(i))
Next
Console.WriteLine("Tipo del arreglo: {0} Propiedad
VectorA.GetType()", VectorA.GetType())
Console.WriteLine("Tiene tamaño fijo? IsFixedSize = {0} Propiedad VectorA.IsFixedSize",
VectorA.IsFixedSize)
Console.WriteLine("Es
de sólo lectura? IsReadOnly = {0} Propiedad VectorA.IsReadOnly",
VectorA.IsReadOnly)
Console.WriteLine("Tiene {0} dimension propiedad
VectorA.Rank", VectorA.Rank)
Console.WriteLine("Cantidad de elementos {0}",
VectorA.GetLength(0))
VectorB.CopyTo(VectorA, 5)
Console.WriteLine("Resultado después de usar la siguiente
instrucción VectorB.CopyTo(VectorA, 5) en el primer vector")
For i = 0 To
VectorA.GetLength(0) - 1
Console.WriteLine("Indice
{0}={1}", i, VectorA(i))
Next
ref = VectorB
Console.WriteLine("Aqui se está referenciando la variable reg que
también es un arreglo a VectorB (ref =
VectorB)")
ref(0) = 3
Console.WriteLine("Resultado después de modificar el valor del
indice 0 del segundo vector con la siguiente instrucción (ref(0) = 3)")
For i = 0 To
VectorB.GetLength(0) - 1
Console.WriteLine("Indice
{0}={1}", i, VectorB(i))
Next
Console.WriteLine("Ahora si lo que queremos es ordenar el segundo
vector")
Console.WriteLine("Lo haremos con cualquiera de estas instrucciones
(VectorB.Sort(VectorB)) ó (Array.Sort(VectorB))")
VectorB.Sort(VectorB)
For i = 0 To
VectorB.GetLength(0) - 1
Console.WriteLine("Indice
{0}={1}", i, VectorB(i))
Next
'Otra forma de recorrer un vector es
Console.WriteLine("Otra forma de recorrer un vector es:")
For Each i In VectorB
Console.WriteLine(i)
Next
End If
Console.Read()
End Sub
End Module
Un último
ejemplito
Option Explicit
On
Option Strict On
Module Module1
Sub
Main()
Dim I,
J As Integer
Dim
MaxDim0, MaxDim1 As Integer
Dim
S(,) As Short =
New Short(,)
{{5, 6}, {7, 8}}
MaxDim0 = S.GetUpperBound(0)
MaxDim1 = S.GetUpperBound(1)
For I =
0 To MaxDim0
For J = 0 To MaxDim1
Console.WriteLine("Fila:
{0}:Columna: {1}:Valor: {2}", I, J, S(I, J))
Next
J
Next I
Console.Read()
End
Sub
End
Module
Las matrices regulares se caracterizan por tener el mismo
número de elementos en cada una de sus dimensiones. Una matriz bidimensional de 10 elementos
tendrá similar número en cada una de sus filas. Basta con saber la cantidad de
los mismos de una de ellas para conocer la cantidad de elementos de las demás.
Existe un tipo adicional de matrices llamadas irregulares
o dentadas las cuales no cumplen la regla anterior. Ellas se caracterizan porque cada fila puede
contener u numero diferente de elementos. Una matriz irregular bidimensional,
por ejemplo podría contener 3 elementos en la primera fila, 10 elementos en la
segunda y 6 elementos en la tercera, moldeando así una figura irregular, aunque
podría se más compleja.
Por ejemplo:
Module Module1
Sub Main()
Dim
irregular() As Array = {New Integer() {1, 2, 3, 4}, _
New Integer() {5, 6,
7}, _
New Integer() {8, 9}}
Dim i,
j As Integer
For i =
0 To irregular.Length - 1
For
j = 0 To irregular(i).Length - 1
Console.WriteLine(irregular(i).GetValue(j).ToString)
Next j,
i
Console.Read()
End
Sub
End
Module
En el ejemplo anterior la variable i llevará la cuenta de
las filas, la variable j mantiene el valor del elemento a leer de la misma, la
propiedad length obtendrá la cantidad total de integrantes de la matriz
principal o raíz, la cual dará como resultado 3, ya que existen únicamente 3
filas.
Sin embargo también se pueden realizar matrices con tipos
de datos diferentes
Por
ejemplo
Dim
Irregular() As Array = {New Integer() {1, 2, 3, 4}, _
New
String() {"Colombia",
"Bogotá","Cundinamarca"}, _
New Long() {8, 9}}
Ahora veremos las estructuras
Las estructuras son parecidas que las enumeraciones pero
con muchas ventajas, entre ellas que cada elemento de la estructura puede ser
de cualquier tipo integer, double, String o matriz, además, se pueden declaran
funciones dentro de la estructura, constructores, ámbito de variables
independientes. Etc.
Una declaración de estructuras empieza con la instrucción
Structure, y finaliza con la instrucción End Structure. Entre estas dos
instrucciones debe declararse por lo menos un miembro.
Si desea mantener un nombre de empleado, su extensión
telefónica y su salario juntos en una única variable, puede declarar una
estructura para esta información de la siguiente manera:
Structure Empleado
Public
Nombre As String
Public
Extension As Long
Private
Salario As Decimal
End Structure
Observe que las variables pueden tener varios tipos de
acceso, en este caso public y private, en el caso de las private solo pueden
acceder a ellas desde procedimientos o funciones que sean públicos y estén en
la misma estructura.
Por ejemplo
Option Explicit
On
Option Strict On
Module Module1
Structure
Empleado
Public
Nombre As String
Public
Extension As Long
Private
Salario As Decimal
Public
Sub Monto(ByVal
Valor As Decimal)
Salario = Valor
End Sub
Public Sub Mostrar()
Console.WriteLine("El
nombre es :{0}", Nombre)
Console.WriteLine("La extensión es :{0}", Extension)
Console.WriteLine("Su salario es :{0}", Salario)
End Sub
End Structure
Sub Main()
Dim
Carlos As Empleado
With Carlos
.Nombre = "Alfonso"
.Extension =
"4598"
.Monto(1500000)
.Mostrar()
End With
Console.Read()
End
Sub
End
Module
Ahora
veremos los constructores para las estructuras, en los constructores podemos
inicializar variables como en el siguiente ejemplo, aunque no es que sea el
gran ejemplo pero introduce varias cosillas como los constructores, las
variables privadas, vectores de tipo estructura, etc.
En este
ejemplo se crean 2 alumnos cada alumno puede crear cualquier cantidad de
materias y cada uno de estas tiene 3 notas
Option Explicit
On
Option Strict On
Module Module1
Structure
notas
Private n1 As Integer
Private
n2 As Integer
Private
n3 As Integer
Public Sub Asignar(ByVal x As Integer, ByVal y As Integer, ByVal z As Integer)
n1 = x
n2 = y
n3 = z
End Sub
Public
Sub MostrarNotas()
Console.WriteLine("Nota 1:{0}", n1)
Console.WriteLine("Nota 2:{0}", n2)
Console.WriteLine("Nota 3:{0}", n3)
End Sub
End Structure
Structure
Alumno
Private
Nombre As String
Private
apellido As String
Private
Telefono As String
Public
Materiaynotas() As notas
Public Sub New(ByVal n As String, ByVal a As String, ByVal t As String)
Nombre = n
apellido = a
Telefono = t
End Sub
Public Sub Mostrar()
Console.WriteLine("Nombre:{0}", Nombre)
Console.WriteLine("Apellido:{0}",
apellido)
Console.WriteLine("Teléfono:{0}", Telefono)
End Sub
End Structure
Sub Main()
Dim Alumno1 As
Alumno = New Alumno("María",
"Perez", "9999999")
Dim Alumno2 As
Alumno = New Alumno("Diana",
"Madrugada", "8888888")
ReDim Alumno1.Materiaynotas(4)’creación
de materias
With Alumno1
.Materiaynotas(0).Asignar(1, 2, 3)’Materia uno
.Materiaynotas(1).Asignar(1, 2, 4) ’Materia dos
.Materiaynotas(2).Asignar(1, 2, 5) ’Materia tres
.Materiaynotas(3).Asignar(1, 2, 6) ’Materia cuatro
.Materiaynotas(4).Asignar(1, 2, 7) ’Materia cinco
Console.WriteLine("Alumno
1")
Console.WriteLine("Materia 1")
.Materiaynotas(0).MostrarNotas()
Console.WriteLine("Materia 2")
.Materiaynotas(1).MostrarNotas()
Console.WriteLine("Materia 3")
.Materiaynotas(2).MostrarNotas()
Console.WriteLine("Materia 4")
.Materiaynotas(3).MostrarNotas()
Console.WriteLine("Materia 5")
.Materiaynotas(4).MostrarNotas()
End With
ReDim Alumno2.Materiaynotas(0) ’creación
de materia
With Alumno2
.Materiaynotas(0).Asignar(3, 3, 3) ’Materia uno
Console.WriteLine("Alumno 2")
Console.WriteLine("Materia 1")
.Materiaynotas(0).MostrarNotas()
End With
Console.Read()
End Sub
End
Module
** A continuación he extraído de la
ayuda las diferencias con respectos a las clases.
Visual
Basic .NET unifica la sintaxis para clases y estructuras, y el resultado
es que ambas entidades admiten prácticamente las mismas características. No
obstante, existen también importantes diferencias entre clases y estructuras.
Similitudes
Las
estructuras y las clases son similares en los siguientes aspectos:
Ambas
tienen miembros, incluyendo constructores, métodos, propiedades, campos,
constantes, enumeraciones y eventos.
Ambas
pueden implementar interfaces.
Ambas
pueden tener constructores compartidos, con o sin parámetros.
Diferencias
Las
estructuras y las clases difieren en los siguientes aspectos:
Las
estructuras son tipos de valor, las clases son tipos de referencia.
Las
estructuras utilizan asignación de pila y las clases utilizan asignación del
montón.
De forma
predeterminada, todos los miembros de estructura son Public y las variables y
constantes de clase son Private, mientras que otros miembros de clase son
Public de forma predeterminada. Este comportamiento de los miembros de las
clases proporcionan compatibilidad con el sistema de valores predeterminados de
Visual Basic 6.0.
Los miembros
de estructuras no pueden declararse como Protected, a diferencia de los
miembros de clase.
Los
procedimientos de las estructuras no pueden controlar eventos, a diferencia de
los procedimientos de clase.
Las
declaraciones de variables de estructura no pueden especificar inicializadores,
la palabra clave New o los tamaños iniciales para matrices; mientras que las
declaraciones de variables de clase sí pueden.
Las
estructuras heredan de forma implícita de la clase ValueType, no pueden heredar
de ningún otro tipo de clase. Las clases pueden heredar de cualquier clase o
clases que no sean del tipo ValueType.
Las
estructuras no son heredables; las clases, sí.
Las
estructuras no se terminan nunca, por lo tanto, Common Language Runtime (CLR)
nunca llama al método Finalize en una estructura; las clases las termina el
recolector de elementos no utilizados, que llama al método Finalize en una
clase cuando detecta que no quedan referencias activas.
Las
estructuras sólo pueden tener constructores no compartidos si pueden tomar
parámetros; sin embargo las clases pueden tener constructores con o sin
parámetros.
Cada
estructura tiene un constructor público implícito sin parámetros. El
constructor inicializa todos los miembros de datos de estructura con sus valores
predeterminados. Este comportamiento no puede redefinirse.
Instancias y variables
Puesto
que las estructuras son tipos de valor, cada variable de estructura está
enlazada de forma permanente a una instancia de estructura individual. Por otro
lado, las clases son tipos de referencia y una variable de objeto puede hacer
referencia a varias instancias de clase. Esta distinción afecta al uso de
estructuras y clases de las siguientes formas:
Una
variable de estructura incluye implícitamente una inicialización de los
miembros mediante el constructor sin parámetros de la estructura.
Por tanto, Dim S As Struct1
equivale a Dim S As Struct1 = New Struct1().
Al
asignar una variable de estructura a otra o pasar una instancia de estructura a
un argumento de procedimiento, se copian los valores actuales de todos los
miembros de variable en la nueva estructura. Al asignar una variable de objeto
a otra o pasar una variable de objeto a un procedimiento, sólo se copia el
puntero de referencia.
Puede
asignar el valor Nothing a una variable de estructura; aunque la instancia
sigue asociada con la variable. Puede seguir llamando a los métodos y
obteniendo acceso a sus miembros de datos, aunque el trabajo inicializa de
nuevo los miembros de variable. En contraposición, si establece una variable de
objeto en Nothing, elimina su asociación con cualquier instancia de clase y no
puede tener acceso a ningún miembro a través de la variable hasta que le asigne
otra instancia.
Una
variable de objeto puede tener asignadas distintas instancias de clase en
momentos distintos y varias variables de objeto pueden hacer referencia a la
misma instancia de clase al mismo tiempo. Los cambios que realice a los valores
de los miembros de clase afectan a dichos miembros cuando se tiene acceso a
estos mediante otra variable que apunta a la misma instancia. Los miembros de
estructura, sin embargo, están aislados dentro de su propia instancia. Los
cambios a sus valores no se ven reflejados en ninguna otra variable de
estructura, incluso en otras instancias de la misma declaración Structure.
La
comprobación de igualdad de dos estructuras debe realizarse mediante una prueba
miembro a miembro. Mediante el método Equals pueden compararse dos variables de
objeto. Equals indica si ambas variables apuntan a la misma instancia.
