Newsgroup: it.comp.lang.visual-basic
Titolo: [?] Array dinamico VS Collection

Ciao a tutti,
una domanda stupida, a cui spero possiate dare una risposta:
è più veloce un array allocato dinamicamente (ogni volta che aggiungo o
tolgo un elemento sono costretto a usare il redim preserve), oppure una
collection? qualcuno ha mai fatto prove di velocità?
grazie in anticipo per la risposta.
ciao, assa.

collection? qualcuno ha mai fatto prove di velocità?
Dipende dalle dimensioni e dal tipo di ricerche che vengono fatte
nell' array/collection.
La soluzione piu' performante e', forse, ridimensionare l' array a blocchi
di n elementi ed utilizzare un array aggiuntivo come indice per le ricerche.
Dipende da quanto tempo puoi dedicare alla scrittura del codice, pero' :-(
-- 
ciao, hal

 Dipende da quanto tempo puoi dedicare alla scrittura del codice, pero' :-(
non devo eseguire alcuna ricerca, soltanto memorizzare delle stringhe in
sequenza e recuperarle direttamente con il loro indice. in questo caso,
quale delle due soluzioni risulta migliore?
ciao, assa.
--
Sito Comune
http://www.it-lang-vb.net/

quale delle due soluzioni risulta migliore?
Se le stringhe sono tante userei un array con Redim Preserve di 10, 50
items per volta (vedi tu).
Devi ovviamente tenere traccia di dove sei arrivato a scrivere. Ad ogni
multiplo di 10, 20, 50, quello che e', fai la Redim.
-- 
ciao, hal

 ha scritto nel messaggio
news:abp6hd$jr9rm$1...@ID-56381.news.dfncis.de...

buona idea :) questo quindi dovrebbe essere piů veloce della collection,
right?
grazie, assa.


right?
_dovrebbe_, se non altro risparmi memoria;
se hai il tempo di provare, magari facci sapere, che una rinfrescata non
guasta mai ;-)
-- 
ciao, hal

guasta mai ;-)
La collection e'  lentissima in lettura, una cosa spaventosa.
I redim sono velocissimi perche' ridimensionano solo lo spazio che
contiene i puntatori ai dati, non fa' differenza se a stringhe o a
altro.
Esiste una mia classe (e' dentro flexagenda sul sito comune) clsBuffer
che gestisce un array autodimensionate.
Salve
           Dbg

 altro.
Mi ri-permetto di dissentire =)
La velocita' di accesso alle matrici dipende dal fatto che esse sono
allocate in zone "contigue" di memoria. Tale tipo di allocazione
permette, avendo il riferimento al primo elemento della matrice, ed il
tipo di dato contenuto (ed il numero di elementi)  di accedere
immediatamente, a partire dall'indice, alla locazione esatta di memoria
in cui si trova l'elemento. La formula che restituisce l'indirizzo di
memoria dell'i-esimo elemento (Option Base 0) di una matrice
monodimensionale e' (i * dimensione_tipo_dato +
indirizzo_primo_elemento).
Per esempio se e' una matrice di 500 elementi di tipo Integer (2 byte) e
l'indirizzo di memoria del primo elemento e' 5600 l'indice del 46esimo
elemento e': (45*2 + 5600) = 5690.
Cio' detto una precisazione  su Redim Preserve:
Redim Preserve alloca fisicamente una nuova area di memoria della
dimensione della matrice incrementata di "uno" (*) o piu' (a seconda
della nuova dimensione passata), copia il contenuto della prima matrice
nella seconda ed assegna al campo/ai campi successivo/i 0 (zero). Cio'
significa che anche se la matrice contiene 50.000 riferimenti (e non
oggetti veri e propri) e quindi la dimensione del singolo elemento (8
byte ?) e' "ridotta" rispetto alla dimensione dell'oggetto "riferito",
facendo Redim Preserve Matrice(0 To 51000), avviene in ordine:
1) Allocazione di 51.000 * 8 byte contigui in memoria (oltre ai 50.000
gia' allocati, per un totale di 101.000 * 8 byte allocati
contemporanemente)
2) Copia in blocco della zona di memoria occupata dalla prima matrice
(50.000*8 byte) nella seconda
3) Deallocazione della prima matrice
4) "Puntamento" della variabile che indica la matrice sulla nuova zona
di memoria
Per contro il metodo .Add delle collection crea un riferimento
all'oggetto specificato e lo aggiunge alla collection in coda (senza
alcuna scansione) alla collection.
E' evidente, quindi, che l'uso di collection e' da prediligere quando
non si conosce a priori la dimensione della matrice che si vuole creare
e si intendono fare molti inserimenti.
Per quanto riguarda invece la lettura dei dati inseriti, le collection
(tranne il caso in cui si adoperi for each, e quindi nelle intere
scansioni), sono tanto piu' veloci quanto piu' l'indice e' prossimo
all'uno (1)! Cio' avviene perche' viene fatta una scansione di tutta la
collection fino a quando non si incontra l'indice (o la chiave, i tempi
sono praticamente identici) cercato.
Viceversa (vd. sopra) nelle matrici l'accesso e' immediato, poiche' a
partire dall'indice esiste una formula che rimanda direttamente alla
locazione di memoria.
--------------------
(*) Per "uno" intendo lo spazio necessario a contenere un nuovo
riferimento all'oggetto del tipo specificato, oppure, nel caso dei tipi
standard, lo spazio di memoria occupato da una variabile di quel tipo.
--------------------
Conclusioni:
Se gli inserimenti sono distinti dalle letture si puo' pensare di
allocare una matrice una tantum solo dopo aver terminato il riempimento
della collection e poi di trasferirvi la collection dentro (ovviamente
con un For Each ... In ... ed un contatore).
Se inserimento e letture non sono separati:
Pochi inserimenti e poche letture: Collection.
Molti inserimenti e poche letture: Collection.
Pochi inserimenti e molte letture : Array dimensionato (in caso) a N a
N.
Se gli inserimenti sono molti e le letture molte, conviene utilizzare un
Array ridimensionato di N in N come hanno gia' detto in molti oppure
una collection *ed* una matrice come sopra indicato.
Il tutto, ovviamente, IMVHO =)
Lokar

 right?
Usa le collection solo se devi usarle come hash-table, cioè se devi
recuperare un elemento tramite chiave.
Le collection sono molto più veloci nell'accesso tramite chiave che tramite
indice, il che è tutto un dire per le prestazioni rispetto agli array.
Ciao

 recuperare un elemento tramite chiave.
Mai pensato di usare le collection presenti sotto Leonardo?
Scritte in VB, sono spesso piů veloci di quelle standard e molto piů
flessibili (es. puoi cambiare il valore di un item).
Ciao