Bom dia.
Eu tenho trabalhado frequentemente com matrizes ( coisa pequena tipo 10.000 linhas por 15 colunas) e o desempenho tem se mostrado superior.
Pela minha pequena experiencia, compensa mais utilizar a técnica do duplo loop: fazer o mesmo loop que irá capturar os dados primeiramente para rodar um contador e limitar o tamanho da matriz.
Tem a técnica do transpor também, vc vai transpondo a matriz toda vez que precisa redimensionar as linhas ( essa eu não usei ainda).
Eu evito ficar usando o redim preserve.

eu mexo com array a um tempo já,
nem uso redim preserve , eu citei pq uso muito range dinâmica
mas redim preserve do array irregular não dá peso já que é uma array de endereços apenas e muito pequena
ReDim Preserve ABB(1 To n)
mas caso se tenha que mexer no dimensionamento dos arrays internos já fica citado

mas como tem que passar para outro array de qualquer forma se pode usar um loop e depois inserir o array de volta

loop
arrb(c,l)=Arry(x)(l,c)
fim loop
Arry(x)=arrb
como pode ver não tem problemas nesse caso "pelo menos eu acho que não

é um pouco mais complicado o uso mas depois que pega o jeito é facil

ontem eu não postei, mas tinha feito uns testes de desempenho

com range inteira
pega dados da planilha

Range("A1:J9711").Value2

tempo = 0.015625
Cola dados na planilha

Range(Cells(L, c), Cells(L + UBound(arr, 1) - 1, c + UBound(arr, 2) - 1)).Value2 = arr

tempo= 0.203125
==========================================================================
==========================================================================

pega dados da planilha :
com uma coluna de cada vez em array de arrays
fazendo ReDim Preserve Arr(1 To n) a cada coluna

 Arr(n) = Range(Cells(1, n), Cells(9711, n)).Value2

tempo = 0.0078125

Cola dados na planilha com loop uma coluna de cada vez e com opção de inversão e colunas não continuas

     For n = ni To nf Step d
          Range(Cells(L, c), Cells(L + UBound(Arr(n), 1) - 1, c)).Value2 = Arr(n)
          c = c + 1
     Next

tempo = 0.2109375

acho que nesse caso arrays irregulares ganha no geral já que apesar de um tempo maior para passar os dados para a planilha se torna mais dinamica no uso

mas a pergunta é
tem algum inconveniente em usar fora a complexidade maior ?

Acho ótima ideia, Ed... Eu já trabalhei com multiplas arrays, mas não array de arrays, era coleção de arrays. Assim eu pegava multiplas arrays, uma para cada coluna, e as colocava numa collection. Visando aumentar a quantidade de dados que eu conseguia usar, contornando a msg de limite de memória. Era uma coleção de matrizes bidimensionais de uma coluna só... Dava quase o mesmo resultado final, mas eu perdi desempenho considerável em matrizes pequenas, mas ganhei desempenho e escalabilidade consideravel em matrizes grandes. Só decidi não continuar, pq a maioria das matrizes com que trabalho, são relativamente relativamente pequenas. Eu não cheguei, à época a trabalhar com array de array, ou array tridimencional.... como eu falei outro dia, eu acho interessante e achei bonito até, o seu exemplo.

Eu confesso que em quase 20 anos de experiencia, não vi necessidade para uma array cubica, mas isso não significa que não existam e não possam ser úteis. Você certamente já passou por experiências onde elas foram necessarias. Quanto ao ReDim preserve, eu uso em meus códigos, mas com cuidado, claro. Disparar em toda iteração de loop, é complicado pq é verdadeiramente lenta. Então há que se ter uma ideia do tamanho da matriz, dimensioná-la conforme seu escopo de utilização, e a cada iteração do loop, verificar se já chegou no fim dela, e se for necessário, usar o transpose e o preserve e o transpose, para dobrar o tamanho, ou usar um incremento consideravel.. e lá no final do loop, daí sim, o ultimo preserve para ela ter tamanho exato..

E claro, você já deve fazer isso, mas vou falar, pq nunca chegamos nesse ponto em nossas conversas... Mais importante do que usar (que é o que eu faço) ou até extrapolar o uso com maestria (que é o que vc faz, rs), é limpar a memória no final. Matrizes aumentam consideravelmente o consumo de memória RAM, e já aconteceu muitas vezes comigo, que quando acabava de executar a rotina, a memória não voltava ao estado inicial. Mais recentemente nas ultimas versões do Excel, eu não consegui replicar o problema, o que me indica que a MS fez algo para que a memória fosse liberada após o VBA terminar. Mas mesmo assim, pelas boas práticas e tb pq nunca sei qual a versão do Excel o meu usuário vai usar, eu limpo a variável das matrizes usando Erase e Empty... Assim se vc fizer no passo a passo, vai perceber o quanto uma array pesa e o quanto conseguimos liberar, se estiver monitorando o Gerenciador de Tarefas.... Mas que fique claro, esse último parágrafo não é pra te ensinar, tenho certeza que vc já sabe. Mas caso alguém acompanhe essa leitura até aqui e não saiba, podem aprender.

Um abs,

FF

Fernando

a gente já "discutiu"

a respeito de redim preserve ,
eu não uso,
eu calculo o tamanho da array antes de entrar no loop
mas no caso de um redim preserve de um array de array não pesa pq é um array apenas de endereço de outros arrays e normalmente teria tamanho limitado

como pode ver mesmo com o redim preserve 10x para ajustar o array irregular o tempo para pegar os dados da planilha ainda foi menor do que para um array de range inteira

a gente tbm já "discutiu" sobre uso e limpeza da memoria
me lembro que não consegui usar Erase e Empty nas minhas arrays, então eu simplesmente usava redim

sobre desoculpar a memoria,
pelo menos no excel 2010 32b que é o que eu tenho faz sim a limpeza na maioria das situações "mas não em todas"
mas tem um comportamento estranho
mesmo sem usar macros, sem adicionar dados ou mexer na planilha , o uso de memória do excel vai subindo de pouco em pouco no tempo que fica aberto a pasta de trabalho

mas em relação ao desempenho array de arrays no geral é bom ,
só é mais demorado para passar devolta para a planilha por causa do loop efetuado, o excel tem uma certa verificação

para pegar é até mais rapido como vc viu , e para trabalhar os dados internos é igual
fora isso tem o ganho da quantidade de dados possíveis

tem sim uma complexidade maior no uso, mas não muito, mas tem

sobre array cubica ,
não é que eu sinta necessidade, claro que no caso que estou usando dá sim um conforto e desempenho melhor
a array que mostrei aquela linha no caso era uma matriz 500x500x10x10x3 mas ainda estou trabalhando no uso dos dados

Pos(1, n)(result(L, C), result(L + Lx(n), C + Cx(n)))
pos(1 to 3, 1 to 10)(1 to 500, 1 to 500, 1 to 10)
no caso isso cria varias matrizes que até poderiam ser separadas , mas como pode ver manipular tantas separadamente iria ser bem tedioso
no caso é para correlacionar dados
result é uma matriz 2d que funciona como um endereçador para essa matriz multidimensional
isso cria uma arvore de posicionamento
mas ainda estou me matando na parte matemática da coisa, na logica eu até que me viro

acho que não tem ninguem do forum que já tenha mexido com isso a ponto de saber se há inconvenientes fora os que encontrei
se nem o Fernando chegou a mexer nisso

no geral só dá um pouco mais de trabalho montar as rotinas mas diante as vantagens como dinamicidade e capacidade acho que pelo menos para mim vale a pena
também vai facilitar uma conexão de valores junto a um BD real, já que cada coluna do bd vai poder ser referenciada diretamente a uma da planilha

vou dar por encerrado já que duvido que apareça alguem com algo a respeito , pelo menos não aqui no forum