manual de vb.net en nuestro idioma parte 6

Ver el tema anterior Ver el tema siguiente Ir abajo

manual de vb.net en nuestro idioma parte 6

Mensaje  HERNAN DARIO RODRIGUEZ el Mar 17 Ago - 10:10:03

Vectores, Matrices y Estructuras



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

Haaaaa...Antes de que se me olvide ahora existen matrices irregulares

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.


avatar
HERNAN DARIO RODRIGUEZ

Mensajes : 14
Puntos : 45
Fecha de inscripción : 04/08/2010
Edad : 35
Localización : cali

Ver perfil de usuario

Volver arriba Ir abajo

Saben para que sirve el NEW?

Mensaje  Admin el Sáb 21 Ago - 0:50:54

recuerden que todo comando tiene su propio nombre para un uso especifico


german andres morales leon

Admin
Admin

Mensajes : 9
Puntos : 14
Fecha de inscripción : 03/08/2010

Ver perfil de usuario http://programacion2.foro-mexico.net

Volver arriba Ir abajo

Ver el tema anterior Ver el tema siguiente Volver arriba

- Temas similares

 
Permisos de este foro:
No puedes responder a temas en este foro.