Objetos armazenados em variáveis Variant
Os objetos podem ser armazenados em variáveis Variant. Isso pode ser útil quando você precisa lidar com vários tipos de dados de maneira eficiente, incluindo objetos. Por exemplo, todos os elementos de uma matriz devem ter o mesmo tipo de dados. Defina o tipo de dados do array como Variant para armazenar objetos junto com outros tipos de dados no mesmo array.
variedade
Se você tem experiência em programação em outras linguagens, deve estar familiarizado com o conceito de arrays. Graças aos arrays, você pode referir-se a uma série de variáveis com o mesmo nome e identificá-las numericamente (indexadas). Em muitas situações, o uso de arrays pode encurtar e simplificar os programas porque você pode projetar um loop usando valores de índice para lidar com múltiplas situações de forma eficiente. As matrizes têm limites superiores e inferiores e os elementos da matriz são contínuos dentro dos limites superior e inferior. Como o Visual Basic aloca espaço para cada valor de índice, não declare uma matriz que seja excessivamente grande.
Observe que os arrays discutidos nesta seção são arrays de variáveis declaradas no programa. Eles são diferentes das matrizes de controle, que são especificadas em tempo de design, definindo a propriedade Index do controle. As matrizes variáveis são sempre contíguas, ao contrário das matrizes de controle, os elementos da matriz não podem ser carregados ou descarregados do meio de uma matriz.
Todos os elementos de uma matriz possuem o mesmo tipo de dados. Claro, quando o tipo de dados é Variant, cada elemento pode conter diferentes tipos de dados (objetos, strings, valores, etc.). Arrays de qualquer tipo de dados básico podem ser declarados, incluindo tipos definidos pelo usuário (veja “Criando seus próprios tipos de dados” no Capítulo 8, “Programando Novamente”) e variáveis de objeto (veja Capítulo 9, “Programando com Objetos”).
Existem dois tipos de arrays no Visual Basic: arrays de tamanho fixo - que sempre permanecem do mesmo tamanho, e arrays dinâmicos cujo tamanho pode mudar em tempo de execução. Matrizes dinâmicas são discutidas em detalhes em "Matrizes Dinâmicas", posteriormente neste capítulo.
Declarar um array de tamanho fixo
Existem três maneiras de declarar um array de tamanho fixo, e o método usado depende do intervalo válido que o array deve ter:
Para criar um array público, declare o array usando a instrução Public na seção de declaração do módulo.
Para criar uma matriz em nível de módulo, declare a matriz usando a instrução PRivate na seção de declaração do módulo.
Crie um array local e declare-o com a instrução Private no processo.
Definir limites superiores e inferiores
Ao declarar um array, o nome do array é seguido por um limite superior entre parênteses. O limite superior não deve exceder o intervalo do tipo de dados Long (-2.147.483.648 a 2.147.483.647). Por exemplo, a seguinte declaração de array pode aparecer na seção de declaração de um módulo:
DimCounters(14)AsInteger '15 elementos.
DimSums(20)AsDouble '21 elementos.
Para criar um array público, substitua diretamente Dim por Public.
Contadores Públicos(14)AsInteger
Somas Públicas(20)AsDouble
A mesma declaração utiliza Dim no procedimento: DimCounters(14)AsIntegerDimSums(20)AsDouble A primeira declaração cria um array com 15 elementos, indexados de 0 a 14. A segunda declaração cria um array com 21 elementos, indexados de 0 a 20. O limite inferior padrão é 0.
Para especificar um limite inferior, use a palavra-chave To para fornecer um limite inferior explícito (para o tipo de dados Long):
DimCounters(1To15)AsInteger
DimSums(100To120)AsString
Na instrução anterior, Contadores possuem valores de índice variando de 1 a 15, enquanto Somas possuem valores de índice variando de 100 a 120.
Matrizes contendo outras matrizes
É possível criar arrays de tipos de dados Variant e colocá-los com arrays de diferentes tipos de dados. O código a seguir cria dois arrays, um contendo inteiros e outro contendo strings. Em seguida, declare um terceiro array Variant e coloque nele os arrays inteiros e de string:
PrivateSubCommand1_Click()
DimintXAsInteger 'Declara variável de contador.
'Declara e coloca um array de inteiros.
DimcountersA(5)AsInteger
ForintX=0To4
contadoresA(intX)=5
PróximointX
'Declara e coloca um array de strings.
DimcountersB(5)AsString
ForintX=0To4
contadoresB(intX)=olá
PróximointX
DimarrX(2)AsVariant 'Declara um novo array com dois membros.
arrX(1)=countersA() 'Move outros arrays para o array.
arrX(2)=contadoresB()
MsgBoxarrX(1)(2) 'Exibe cada membro do array.
MsgBoxarrX(2)(3)
Fim Sub
matriz multidimensional
Às vezes é necessário rastrear informações relevantes em um array. Por exemplo, para rastrear cada pixel na tela de um computador, você precisa fazer referência às suas coordenadas X e Y. Neste momento, arrays multidimensionais devem ser usados para armazenar valores. Matrizes multidimensionais podem ser declaradas com Visual Basic. Por exemplo, a instrução a seguir declara uma matriz bidimensional 10×10 dentro de um procedimento.
StaticMatrixA(9,9)AsDouble
Você pode declarar uma ou ambas as dimensões com um limite inferior explícito:
StaticMatrixA(1To10,1To10)AsDouble
Tudo isso pode ser generalizado para matrizes de mais de duas dimensões. Por exemplo:
DimMultiD(3,1To10,1To15)
Esta declaração cria uma matriz tridimensional de tamanho 4×10×15. O número total de elementos é o produto das três dimensões, que é 600.
Observe que ao aumentar a dimensão de um array, o espaço de armazenamento ocupado pelo array aumentará significativamente, portanto, arrays multidimensionais devem ser usados com cautela. Tenha muito cuidado ao usar arrays Variant porque eles exigem maior espaço de armazenamento.
Usando loops para manipular arrays
Você pode usar loops For aninhados para processar matrizes multidimensionais com eficiência. Por exemplo, em MatrixA, cada elemento recebe um valor com base em sua posição na matriz:
DimIAsInteger,JAsInteger
StaticMatrixA(1To10,1To10)AsDouble
ParaI=1To10
ParaJ=1To10
MatrizA(I,J)=I*10 J
PróximoJ
PróximoEu
Mais informaçõesPara obter mais informações sobre loops, consulte a seção "Estruturas de loop", posteriormente neste capítulo.
matriz dinâmica
O tamanho que uma matriz deve ter às vezes é desconhecido. Portanto, espero poder alterar o tamanho do array em tempo de execução.
Matrizes dinâmicas podem mudar de tamanho a qualquer momento. No Visual Basic, os arrays dinâmicos são os mais flexíveis e convenientes, ajudando a gerenciar a memória de maneira eficaz. Por exemplo, você pode usar um array grande por um curto período e então liberar espaço de memória para o sistema quando o array não estiver em uso.
Se você não usar um array dinâmico, declare um array com o maior tamanho possível e apague os elementos desnecessários. No entanto, se esse método for usado excessivamente, o ambiente operacional da memória ficará lento.
Para criar uma matriz dinâmica, siga estas etapas:
1. (Se você quiser que o array seja um array público, então) declare o array com a instrução Public, ou (se você quiser que o array seja um nível de módulo, então) declare o array com a instrução Dim no nível do módulo , ou (se você quiser que o array seja um array local, então) em Use a instrução Static ou Dim para declarar o array durante o procedimento. Declare a matriz como dinâmica anexando uma tabela de dimensões vazia a ela.
DimDynArray()
2. Use a instrução ReDim para alocar o número real de elementos.
ReDimDynArray(X 1)
As declarações ReDim só podem aparecer dentro dos procedimentos. Diferente da instrução Dim e da instrução Static, a instrução ReDim é uma instrução executável. Por causa dessa instrução, o aplicativo executa uma operação em tempo de execução. A instrução ReDim oferece suporte a uma sintaxe igual à usada com matrizes fixas. Para cada dimensão, cada instrução ReDim pode alterar o número de elementos e os limites superior e inferior. No entanto, as dimensões da matriz não podem ser alteradas.
ReDimDynArray(4to12)
Por exemplo, use a matriz dinâmica Matrix1 criada no nível do módulo pela primeira vez:
DimMatrix1()AsInteger
Em seguida, aloque espaço para o array no procedimento:
SubCalcValuesAgora()
.
.
.
ReDimMatrix1(19,29)
Fim Sub
A instrução ReDim aqui aloca uma matriz inteira 20×30 para Matrix (o tamanho total do elemento é 600). Existe outra maneira de usar variáveis para definir os limites de matrizes dinâmicas:
ReDimMatriz1(X,Y)
Observe que você pode atribuir uma string a uma matriz de bytes de tamanho variável. Uma matriz de bytes também pode ser atribuída a uma string de comprimento variável. É importante observar que o número de bytes na string varia de acordo com a plataforma. A mesma string tem o dobro de bytes em uma plataforma Unicode do que em uma plataforma não Unicode.
Preservar o conteúdo de um array dinâmico
Cada vez que uma instrução ReDim é executada, todos os valores armazenados atualmente no array são perdidos. O Visual Basic redefine o valor de um elemento de matriz para Vazio (para uma matriz Variant), para 0 (para uma matriz Numeric), para uma string de comprimento zero (para uma matriz String) ou para Nothing (para uma matriz de objetos) .
Isso é útil ao preparar um array para novos dados ou quando você deseja reduzir o tamanho do array para economizar memória. Às vezes, você deseja alterar o tamanho de um array sem perder os dados do array. Isso pode ser feito usando a instrução ReDim com a palavra-chave Preserve. Por exemplo, usar a função UBound para referenciar o limite superior faz com que o array se expanda e adicione um elemento sem perder o valor do elemento existente:
ReDimPreserveDynArray(UBound(DynArray) 1)
Ao usar a palavra-chave Preserve, você só pode alterar o limite superior da última dimensão em uma matriz multidimensional; se alterar o limite inferior de outras dimensões ou da última dimensão, ocorrerá um erro em tempo de execução; Então pode ser programado assim:
ReDimPreserveMatrix(10,UBound(Matriz,2) 1)
Em vez de programar assim:
ReDimPreserveMatrix(UBound(Matriz,1) 1,10)
Para obter informações mais detalhadas sobre matrizes dinâmicas, consulte "Função ReDim" na referência da linguagem. Para obter informações sobre matrizes de objetos, consulte o Capítulo 9, “Programando com Objetos”.
->