Visual Basic 6  - Trabalhando com Arrays

Arrays ????
Rápido um dicionário !!!

Uhn... Vejamos...

Arrays - Tipo de variável que armazena um conjunto de valores do mesmo tipo ; Um arranjo de elementos em
uma ou mais dimensões ; Uma coleção de elementos do mesmo tipo no qual a posição de cada elemento está
definida de forma única por um inteiro.

Obs: Os arrays são semelhantes aos vetores , se você já ouviu falar em vetores e conhece algo sobre eles
verá que os conceitos envolvidos são semelhantes.

Acho que não foi um bom começo , mas , vamos tentar melhorar. 

Primeiro : não vou traduzir a palavra array.

Array será entendido como um tipo de variável especial.

Segundo: vamos ser mais práticos...

Vamos supor que você precise atribuir a três variáveis o nome de três pessoas que constam de uma relação.
Como você faria ? Ora, ora... abaixo as três etapas básicas envolvidas no tedioso processo...

snome1="João da Silva
dim snome1 as string for i=1 to 3
snome2="Maria Lima"
dim snome2 as string    msgbox snome & i
snome3="Pedro
dim snome3 as string Next
Sabino"
declarando as exibindo o conteúdo
atribuindo valores
variáveis das variáveis

Você teve que declarar 3 variáveis diferentes , uma para armazenar cada nome, mesmo cada nome sendo do
uma variável do tipo string.

Muito Bem, e se a relação tiver 5 pessoas e você precisar atribuir os nomes a variáveis ???  Ô Loco !!!!

Ora por isso é que inventaram os arrays . Vejamos como ficaria...:

sNomes(1)="João da
Silva"
sNomes(2)="Maria
Lima"
for i=1 to 5
Dim sNomes(1 to 5) as sNomes(3)="Pedro
   msgbox snomes(i)
String Sabino"
Next
sNomes(4)="Marcia de
Souza"
sNomes(5)="Carlos
Manga"
declarando as exibindo o conteúdo
atribuindo valores
variáveis das variáveis

O que há de novo ?

Você declarou somente uma variável - sNomes

Cada nome foi atribuído à variável sNomes , sendo diferenciado apenas por um índice numérico:
sNomes(1), sNomes(2), sNomes(3) , sNomes(4) , sNomes(5)
 Para recuperar o conteúdo de cada variável usamos o numero que identifica de forma única cada nome
em cada variável.

Tudo se passa como se você tivesse um "armário" com 5 "gavetas " , cada gaveta possuindo um número de
identificação , e armazenando um nome distinto.

Conclusão :

1. Os Arrays permitem que definamos uma série de variáveis pelo mesmo nome diferenciando-as através
de um número inteiro chamado índice.
2. Todos os elementos de um array devem ser do mesmo tipo de dado: string , integer, etc.... ( para que os
elementos possam conter diferentes tipos de dados (strings , integers, objects, etc...) você deve definir o array
como do tipo Variant )
3. A quantidade de variáveis definidas por cada índice (número) determina o tamanho do array.

Nota -  Os arrays possuem a seguinte característica:

Ao declarar um array da seguinte forma:  Dim Teste(4)  o array possuirá 5 elementos pois o primeiro
elemento terá como índice o número zero. Assim : Teste(0) ,Teste(1), Teste(2), Teste(3) , Teste(4)
Para fugir a esta característica basta você definir o índice inferior e superior do array  , assim : Dim Teste(1
to 5) irá produzir :Teste(1) ,Teste(2), Teste(3), Teste(4) , Teste(5)

O VB trabalha com dois tipos de arrays : os fixos , que sempre permanece do mesmo tamanho e os
dinâmicos cujo tamanho pode ser alterado em tempo de processamento.

Arrays Fixos
A sintaxe para declarar um array fixo é:

Dim Nome_do_Array(Índíce_Inferior To Índice_Superior) As Tipo_de_Dados

Onde:

1. Nome_do_Array - O nome dado ao array

2. Indice_Inferior - o primeiro elemento do array
3. Indice_Superior - o último elemento
4. Tipo_de_Dados - um tipo de dados válido. (Integer, Double, String, Date, etc...)

Ex: Dim Numeros(10) as Integer  ,  Dim Nomes(10) as String

Dica - Um laço For/Next é uma das maneiras mais tradicionais de percorrer os elementos de um array e de
atribuir valores a um array. geralmente usamos a sintaxe abaixo:

For i=
For i=
indice_inferior to
indice_inferior to
indice_superior
indice_superior
      
        Print 
Nome_do_vetor(i)
Nome_do_vetor(i)
= Variável
Next i
Next i
atribuindo valores percorrendo o
array

Obs: A partir do VB5 temos também o laço For Each ...Next , o qual é específico para ser usado com coleções
e arrays. A sintaxe é:

For Each <Variant>  In <nome_do_array> ... Next         

Vejamos um exemplo:
Dim nRandom() As Integer
Dim Elemento As Variant
Dim nTamanhoArray as integer

Randomize

nTamanhoArray = Int (Rnd(1)) * 10)  '

gera tamanho do vetor aleatório

Redim nRandom(nTamanhoArray)

For Each Elemento in nRandom   

'percorre cada elemento do array e
atribui um valor
    Elemento = int(Rnd(1) * 1000)
Next

Nota - Lembra-se do que uma variável do tipo Variant ?

Tipo de dados descrição      Pode receber Tamanho

Variant   qualquer tipo de variável Qualquer valor 22 bytes + tipo de
dado

Podemos declarar um array fixo das seguintes formas com relação a visibilidade do mesmo no projeto:

1. Em um formulário ; local  - Dim ou Private

2. Em um módulo , para ser visível por todo o projeto - Public
3. Em uma procedure ; local - Dim

Nota - Lembra-se do escopo das variáveis ?

Escopo Visibilidade
Local uma variável definida a nível de procedure só é visível
dentro da procedure onde foi declarada
Módulo uma variável declarada na General Declaration de
/Formulário um módulo ou de um formulário só é visível para
todas as procedures dentro do módulo ou formulário
onde foram declaradas
Público uma variável declarada em um módulo como Public é
visível em todas as procedures de seu projeto

Ao declarar um array você não pode exceder o intervalo do tipo de dados Long ( -2.147.483.648 to
-2.147.483.647) . Um número muito grande pode consumir muita memória. Por exemplo:

Veja as implicações de você declarar o seguinte array :  Dim Teste(20000) As Long

Cada elemento do seu array vai ser do tipo Long ; cada variável Long ocupa 4 bytes de memória
O array Teste precisará de 80.004 bytes de memória (20.001 x 4 ). Você acha pouco ????
Se você tiver 10 vetores idênticos no seu projeto terá consumido 800.040 bytes de memória.

Arrays contendo Arrays

Você pode criar um array do tipo Variant que contenha outros arrays de diferentes tipos de dados. O código
abaixo mostra exatamente isto:
Private Sub Command1_Click()
Dim i As Integer
'declara um array do tipo inteiro e atribui valores
Dim contadorA(3) As Integer
For i = 0 To 2
contadorA(i) = i
Next i

' declara um array do tipo string e atribui valores

Dim contadorB(3) As String
For i = 0 To 2
contadorB(i) = "Elemento - " & i
Next i

'declara um array do tipo variant

Dim arrX(2) As Variant

'atribui os arrays definidos anteriormente como elementos deste novo array

arrX(1) = contadorA()
arrX(2) = contadorB()

'contadorA()
MsgBox arrX(1)(0) 'exibe o elemento de cada array
MsgBox arrX(1)(1)
MsgBox arrX(1)(2)

' contadorB()
MsgBox arrX(2)(0)
MsgBox arrX(2)(1)
MsgBox arrX(2)(2)

End Sub

Entendendo:

1. Primeiro declaramos o vetor ContadorA como do tipo inteiro com 3 elementos e atribuímos os números
0 , 1 e 2 ao array
2. A seguir declaramos o vetor ContadorB como do tipo String com 3 elementos e atribuímos os números
Elemento - 0 ,Elemento - 1 e Elemento - 2 ao  array
3. Finalmente declaramos o vetor arrX(2) como sendo do tipo Variant e atribuímos os vetores declarados
anteriormente como sendo elementos deste vetor. (Arrx(1)=contadorA()   e ArrX(2)=ContadorB())
4. Para exibir os elementos do vetor usamos um índice para identifica o elemento do vetor e outro índice
que identifica o elemento do vetor que foi atribuído . Assim temos:

   'contadorA()
   MsgBox arrX(1)(0)  == >   0
   MsgBox arrX(1)(1)  == >   1
   MsgBox arrX(1)(2)  == >   2
  
  ' contadorB()
  MsgBox arrX(2)(0)  == >   Elemento - 0
   MsgBox arrX(2)(1)  == >   Elemento - 1
   MsgBox arrX(2)(2)  == >   Elemento - 2
Para determinar os limites inferiores e superiores de um array podemos usar as funções UBound e LBound.
Assim:

LBound - Retorna um valor do tipo Long contendo o MENOR índice para a dimensão definida de um array.
Sintaxe:     LBound(nome_do_array[, dimensão])

Parte Descrição
nome_do_array Nome do Array. Obrigatório
dimensão Opcional; Variant (Long). Indica qual a dimensão para qual o menor índice é retornado.Se
for omitido o padrão é 1.

Exemplo: Dim A(1 To 100, 0 To 3, -3 To 4) - Vetor com três dimensões:

Usando LBound Valor descrição
LBound(A, 1) 1 retorna o menor índice da primeira dimensão
LBound(A, 2) 0 retorna o menor índice da segunda dimensão
LBound(A, 3) -3 retorna o menor índice da terceira dimensão

UBound - Retorna um valor do tipo Long contendo o MAIOR índice para a dimensão definida de um array.
Sintaxe:     LBound(nome_do_array[, dimensão])

Parte Descrição
nome_do_array Nome do Array. Obrigatório
dimensão Opcional; Variant (Long). Indica qual a dimensão para qual o MAOIR índice é retornado.Se
for omitido o padrão é 1.

Exemplo:

Dim Superior
Dim MeuArray(1 To 10, 5 To 15, 10
To 20)   ' declara arrays
multidimensional , no caso 3
dimensoes
Dim QualquerArray(10)

Superior = UBound(MeuArray, 1)       

' Retorna 10.
Superior = UBound(MeuArray, 3)       
' Retorna 20.
Superior = UBound(QualquerArray)    
' Retorna 10. (refere-se a primeira
dimensão)

Qual a utilidade de tudo isto ???? (Se não perguntou , devia...)

Os arrays são muito usados para preencher Listas e controles como ListBox/ComboBox/ListView,etc. e
podemos usá-los também para serem preenchidos com o conteúdo de um Recordset. Para ilustrar isto
vejamos o exemplo a seguir  que usa o método GetRows para armazenar em um vetor os dados de uma
tabela:

Inicie um novo projeto no VB e no formulário padrão insira um botão de comando e um controle

MSFLexGrid
A seguir insira o seguindo código no evento clique no botão de comando:

Private Sub Command1_Click()

Dim contador As Integer
Dim dbvetor As Variant
Set db =
DBEngine.Workspaces(0).OpenDatabase("c:\teste\biblio.mdb")
Set rs = db.OpenRecordset("Authors", dbOpenTable)

dbvetor = rs.GetRows(10)   'retorna 10 registros e

armazena-os no vetor dbvetor

rs.Close
Set rs = Nothing
db.Close

numero_de_colunas = UBound(dbvetor, 1)
numero_de_registros = UBound(dbvetor, 2)

'define o numero de colunas do grid

Grid1.Cols = numero_de_colunas
'defina as linhas e colunas fixas
Grid1.FixedCols = 0
Grid1.FixedRows = 1

'Preenche o grid
For i = 0 To numero_de_registros
     For j = 0 To numero_de_colunas
         linha = linha & dbvetor(j, i) & Chr(9)
     Next j
     Grid1.AddItem linha
     linha = ""
Next i
End Sub

O resultado do processamento será o seguinte:

Vamos entender o código acima:

1. dbvetor= rs.GetRows(10) - Retorna os 10 primeiros registros do recordset e os armazena na variável

bidimensional dbvetor; dbvetor tem duas dimensões dbvetor(1,2) : a primeira identifica os campos a
segunda os registros.
2. Após selecionarmos os registros e armazená-los em uma variavel não precisamos mais do recordset nem
da base de dados , por isso fechamos tudo: rs.close , db.close
3. Determinamos o número de campos dos registros selecionados e o numero de registros retornados
usando a função UBound. Esta função tem a seguinte sintaxe: UBound(nome_do_vetor[, dimensão])

Assim quando fizemos:

numero_de_colunas = Ubound(dbvetor,1)
numero_de_registros = Ubound(dbvetor,2)

Estamos retornando em numero_de_colunas o maior valor do índice para a primeira dimensão: Ora este é o
valor relacionado a quantidade de campos selecionado e estamos retornando em numero_de_registros o
maior valor para índice da segunda dimensão que é o valor relacionado com a quantidade de registros.

Outro exemplo de utilização seria o preenchimento de ListBox ou ComboBox com o conteúdo de um array
usando as propriedades UBound e LBound. Vejamos a seguir:

menor = LBound(gVetor)   '

obtem o menor indice do
array
maior  = UBound(gVetor)   '
obtêm o maior indice do
array

For i=menor To Maior

    'insere um novo item do
array na lista
    List1.AddItem gVetor(i)
Next

Arrays Multidimensionais
Podemos declarar arrays de mais de uma dimensão; fazemos isto informando outro valor para o índice que
comporá a outra dimensão.A sintaxe para a declaração é a mesma da usada nos arrays unidimensionais. Assim
temos:

- Array com duas dimensões  -  Dim Duas_Dimensoes(4,4) as integer

Declara um array com 5 elementos em duas dimensões(Lembre-se que o índice inferior inicial é sempre zero).
Desta forma o vetor pode ser entendido como uma tabela com 5 linhas e 5 colunas. A primeira dimensão ,
representando as linhas são identificadas pelos índices de 0 a 4 e a segunda dimensão seriam as colunas
identificadas pelos índices de 0 a 4. O total de elementos do array será 25 elementos (  5 x 5 ).

0,0 0,1 0,2 0,3 0,4

1,0 1,1 1,2 1,3 1,4
2,0 2,1 2,2 2,3 2,4
3,0 3,1 3,2 3,3 3,4
4,0 4,1 4,2 4,3 4,4

Assim: 

 Duas_Dimensoes(0,0) representa o conteúdo da linha 1 e da coluna 1

 Duas_Dimensoes(2,3) representa o conteúdo da linha 3 e da coluna 4
 Duas_Dimensoes(4,4) representa o conteúdo da linha 5 e da coluna 5

- Array com três dimensões  -  Dim Tres_Dimensoes(4,4,4) as integer

Declara um array com 5 elementos em cada dimensão. Aqui estamos tratando com a noção de volume (
Altura, Largura , Profundidade) - imagine em um cubo. O total de elementos deste array será 125 ( 5 x 5 x 5 ).
Podemos identificar os elementos da seguinte forma: 

Tres_Dimensoes(0,0,0)
Tres_Dimensoes(1,1,1)
 Tres_Dimensoes(2,1,0)

Abaixo temos uma representação gráfica simplificada de como seria a terceira dimensão.

Você , ao declarar um array multidimensional , pode definir o índice inicial e final para cada dimensão usando
a palavra chave To, então para o caso acima teríamos:

- Array com três dimensões  -  Dim Tres_Dimensoes(1 To 5,1 To 5,1 To 5) as integer

Neste caso o índice inicial seria 1 e o final 5 para cada dimensão.

Para percorrer ou atribuir valores para arrays multidimensionais os laços For/Next são muito úteis. Vejamos
abaixo um exemplo de como preencher um array bidimensional :

Dim I As Integer, J As Integer

Static MatrixA(1 To 10, 1 To 10) As Double ' define um array bidimensional com 100 elementos

For I = 1 To 10 ' indice das linhas

For J = 1 To 10 ' indice das colunas
MatrixA(I, J) = I * 10 + J ' atribui valores a cada elemento do array
Next J
Next I

Arrays Dinâmicos
Pode acontecer que num determinado momento você não saiba exatamente qual o tamanho do seu vetor, ou
pode acontecer também que após você definir um array com um tamanho ter que alterar o este tamanho quer
aumentando quer diminuindo. Como fazer isto ????

Para resolver estes problemas usamos os arrays dinâmicos , eles podem ser redimensionados a qualquer
momento , além de permitir um gerenciamento de memória mais amigável , pois você pode usar um array
definido para uma quantidade de elementos muito grande num momento e após usá-lo poderá liberar a
memória usada por ele redimensionando-o para quantidades menores de elementos.

Para criar  um array dinâmico basta declarar o array sem definir os índices inferiores e superiores das
dimensões., isto é, você não define o tamanho do array .Exemplo:   Dim Nomes()   as String

Para alocar o número atual de elementos do array você deve usar a declaração ReDim. Assim

Redim Nomes (10)   , ReDim (4 To 10) 

A declaração ReDim somente pode ser usada em uma procedure . 

Então primeiro você declara o array  (Dim) e define o seu tamanho em seguida para , se for o caso,
redimensioná-lo usando a declaração ReDim. Vejamos um exemplo:

Private Sub Command1_Click()

Dim MyArray() As
Integer              ' Declare um array
dinamico
ReDim
MyArray(5)                            '
Aloca 5 elementos
For I = 1 To 5
    MyArray(I) = I                         '
Inicializa o array
Next I
For I = 1 To 5
   Debug.Print MyArray(I)             
'exibe o conteudo do array
Next I

ReDim MyArray(10)             '

redimensiona o array para 10
elementos
For I = 1 To 10
    Debug.Print MyArray(I)              '
exibe o conteudo do array
Next I
For I = 1 To 10
   MyArray(I) = I                         '
atribui valores ao array
Next I
For I = 1 To 10
   Debug.Print MyArray(I)              ' 
exibe o conteudo do array
Next I

ReDim Preserve
MyArray(15)        ' Redimensiona
o array para 15 elementos
For I = 1 To 15
    Debug.Print MyArray(I)           '
exibe o conteudo do array
Next I

End Sub

 Vamos explicar o código em detalhes:

Dim MyArray() As
Integer              ' Declare um
array dinamico
ReDim
MyArray(5)                            '
Aloca 5 elementos
For I = 1 To 5
    MyArray(I) =
I                         ' Inicializa o
array
Next I
For I = 1 To 5
   Debug.Print
MyArray(I)              'exibe o
conteudo do array
Next I

Declaramos o array dinâmico e a seguir alocamos 5 elementos para o array,  a seguir atribuímos valores a cada
elemento do array e exibimos o resultado que será :   1 , 2 , 3 , 4 e 5

ReDim MyArray(10)             '

redimensiona o array para 10
elementos
For I = 1 To 10
    Debug.Print
MyArray(I)              ' exibe o
conteudo do array
Next I
For I = 1 To 10
   MyArray(I) = I                         '
atribui valores ao array
Next I
For I = 1 To 10
   Debug.Print
MyArray(I)              '  exibe o
conteudo do array
Next I

Redimensionamos o array para 10 elementos e exibimos a seguir o conteúdo do mesmo. Aqui vamos observar
que o resultado será: 0,0,0,0,0,0,0,0,0,0 , ou seja o conteúdo do array que antes era 1,2,3,4,5 foi perdido.
Atribuímos então novos valores aos elementos do array e exibimos o resultado que será : 1,2,3,4,5,6,7,8,9 e 10.

ReDim Preserve
MyArray(15)        ' Redimensiona
o array para 15 elementos
For I = 1 To 15
    Debug.Print MyArray(I)           '
exibe o conteudo do array
Next I

Aqui redimensionamos novamente o array , agora usando a palavra chave Preserve , para 15 elementos e a
seguir exibimos o conteúdo do array. O resultado será:  1,2,3,4,5,6,7,8,9 , 10 ,0 ,0 ,0 ,0, 0  ,  ou seja o conteúdo
anterior foi preservado e os novos elementos incluídos com valores 0. (valores numéricos são inicializados com
zero , strings com comprimento zero ("") , variant com vazio (empty)

Conclusão:
Ao redimensionar um array usando a palavra chave ReDim o conteúdo do array será perdido . Para evitar tal
efeito devemos usar a palavra Preserve na declaração. Ex: RedDim Preserve Teste(1 To 15) As Integer 

Você pode usar a declaração ReDim repetidamente para alterar o numero de elementos e dimensões de um
array. Porem você não pode declarar um array de um tipo de dados e mais tarde usar a declaração Redim
para alterar o tipo de dados a menos que o tipo de dados usado foi o Variant, neste caso a alteração pode ser
feita usando a cláusula As.
Ao usar a palavra chave Preserve , você pode redimensionar somente a última dimensão do array  você não
pode alterar o número dimensões. Assim se você usou um array com uma dimensão , você pode alterar a
dimensão , mas se você usou um array com duas dimensões você somente pode alterar a última dimensão e
ainda preservar o conteúdo do array.

Exemplo: ReDim X(10, 10, 10) ==> ReDim Preserve X(10, 10, 15)

Ficamos por aqui..

Veja os Destaques e novidades do SUPER DVD

Visual Basic  (sempre atualizado) : clique e
confira !

Quer migrar para o VB .NET ?

Veja mais sistemas completos para a plataforma

.NET no Super DVD .NET , confira...

Quer aprender C# ??

Chegou o Super DVD C#  com exclusivo material de

suporte e vídeo aulas com curso básico sobre C#.

Veja também os Cursos com vídeo aulas e projetos

exemplos:

VB .NET Básico - Vídeo Aulas

C# Básico - Vídeo Aulas

    Gostou ?   Compartilhe no Facebook   Compartilhe no Twitter

Referências:

Seção VB .NET do Site Macoratti.net

Super DVD .NET - A sua porta de entrada na plataforma .NET
Super DVD Vídeo Aulas - Vídeo Aula sobre VB .NET, ASP .NET e C#
Seção C# do site Macoratti.net
Seção Visual Basic 6 do site Macoratti .net
Trabalhando com Arrays - Macoratti.net
C# - Apresentando Arrays - Macoratti.net

José Carlos Macoratti