Vectores, Matrices y Estructuras en VB.net

Fecha: 24/Feb/2005 (16 de Febrero del 2005)
Autor: Jesús Enrique Gonzáles Azcarate
Email: cyber_fox6@hotmail.com

 


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.

 


ir al índice