Newsgroup: it.comp.lang.visual-basic
Titolo: Domanda elementare? ARRAY

Ciao a tutti,
Ho un problema che potrebbe sembrare abbastanza elementare, però mi ha
bloccato e non riesco a risolverlo:
Devo dichiarare un array però non posso sapere a priori il numero di
elementi di quest'ultimo (varia a seconda di diversi calcoli
matemaici). Come posso fare a inizializzarlo ed ad utilizzarlo
considerando che devo caricarlo prima del calcolo della dimensione
finale?
Spero di essere stato abbastanza chiaro, e vi ringrazio per tutti i
consigli o link che mi mandate...
ciao ciao

 finale?
Devi inizializzare senza dimensioni e poi dimensionare.
Dim array() as string
Redim [Preserve] array(100) 
Con la guida vedi le varie parole chiave.
Tieni presente che redimmare di 1 in 1 spesso è "lento". Io di solito
ridimensiono a blocchi di 10/100/1000 e poi ridimensiono alla fine secondo
gli elementi che ho messo.

Devo dichiarare un array però non posso sapere a priori il numero di
elementi di quest'ultimo (varia a seconda di diversi calcoli
matemaici). Come posso fare a inizializzarlo ed ad utilizzarlo
considerando che devo caricarlo prima del calcolo della dimensione
finale?
**********************************************
Guida VB.
Istruzione ReDim
-- 
---------------------------
Mauro Gamberini
http://www.riolab.org/
 

>...redim...
Cavoli, molto più semplice di quanto pensassi....
Grazie per la doppia risposta.
Marcelo

 Redim [Preserve] array(100)
Redim [Preserve] array(100) AS STRING
(Non dimenticare il tipo).
--------------------------------
Inviato via 
http://arianna.libero.it/usenet/

 (Non dimenticare il tipo).
Usandolo sempre col Preserve, (in questo caso il tipo non si modifica), non
me ne ero accorto.

 (Non dimenticare il tipo).
Non è obbligatorio... l'esplicitazione del tipo è opzionale e comunque 
questo non può essere diverso da quello utilizzato nella Dim (a meno che 
l'array non sia contenuto in un Variant). A maggior ragione col Preserve.
Bye
Raf 

> questo non può essere diverso da quello utilizzato nella Dim
E' proprio per questo che suggerisco di ridichiarare il tipo: per non
rischiare di usarne due diversi, come
    Dim x() As Long
    [.....]
    Redim x(100) As Currency
questo causa un errore, quindi attira l'attenzione sul tipo da assegnare.


 assegnare.
Sarň io che ragiono al contrario ;-), perň mi pare che proprio omettendo il 
tipo si eviti alla radice il rischio di sbagliarsi...

 tipo si eviti alla radice il rischio di sbagliarsi...
No, il tuo ragionamento č giusto ma io sto dicendo un'altra cosa:
dichiarandolo doppio non si evita l'errore di dichiarazione non
corrispondente, ma se ci si fosse dimenticati di che tipo doveva essere una
variabile in questo caso l'errore ci riporta l'attenzione. Cosě, in seguito,
si riduce il rischio di assegnare alla matrice un valore sbagliato ("... No,
qui il currency non ci va perché l'ultima volta ho avuto un errore....").
Io faccio cosě quando ho un codice lungo, in cui ridimensiono la matrice
molto lontano dal punto in cui l'ho dichiarata. Inoltre quando il codice č
lungo il vantaggio č anche di ripetere lě vicino il tipo di dato necessario.
Ma sono solo sottigliezze personali...


 lungo il vantaggio è anche di ripetere lì vicino il tipo di dato necessario.
In effetti può aver senso. Anche se di solito evito di redimmare array
palesemente lontani. Oppure per vedere il tipo sono abituato al CTRL+i.
Comunque basterebbe usare la denominazione Ungherese o qualcosa del genere
asValori() as string
aiValori() as integer
alValori() as long

 sottigliezze personali...
Chiarissimo, in effetti capisco che in certi casi può avere una sua utilità.
Ciao
Raf