Nel VB era pure possibile stabilire gli indici di partenza e arrivo, tipo:
DIM array(5 TO 20) AS STRING
Comunque... basta un ciclo For: :-\
Dim a As New Byte[21]
Dim j As Byte
For j = 5 To 20
a.Add(j, j)
Next
Esempio banalissimo: devo caricare in un array dei dati che vanno dall'anno 1982 fino al 2008.
Sarà più pratico scrivere:
DIM dati(1982 TO 2008) AS variabilestrutturata
puntando direttamente all'anno desiderato, oppure:
Dim variabilestrutturata[26]
dovendo calcolare quale elemento usare tenendo conto dell'anno di partenza scalato poi lo zero?
E' solo un esempio semplicino, ma si può fare di meglio. :)
In Gambas dovrebbe essere:
Dim variabilestrutturata[27] As ...quel_che_è
dato che dal 1982 al 2008 sono 27 anni (tutti compresi).
Insomma, il VB ti fa il calcolo lui, in Gambas il calcolo te lo fai prima tu.
Ma potresti fare lo stesso con il ciclo FOR:
Public Sub Button1_Click()
Dim variabilestrutturata As New Integer[]
Dim j As Integer
For j = 1982 To 2008
variabilestrutturata. Add(j)
Next
' Se andiamo a vedere la quantità di elementi caricati,
Print variabilestrutturata.Count
' avremo il risultato di 27 !
End
Insomma, non mi sembra poi chissà quale grande problema, eh ? :-\
Ma gli indici effettivi vanno da 1982 a 2008 o da 0 a 26?
Edit: provato, la numerazione non viene memorizzata e parte sempre da 0.
Del resto, in un array di quantità di elementi non-definita (e con elementi non ancora valorizzati), non ha senso partire, ad esempio, da 1982. :-\
Questo può avere senso in un array definito, come ho più volte mostrato innanzi.
Esempio:
Public Sub Button1_Click()
Dim variabilestrutturata As New Integer[27]
Dim j As Integer
' Partiamo dal 21° elemento (cioè indice 20):
For j = 20 To 27
' Inserisce un valore nell'elemento di indice
' indicato ad ogni giro dal ciclo FOR:
variabilestrutturata.Add(j, j)
Next
' Verifica:
For j = 0 To 27
Print variabilestrutturata[j]
Next
End
non riesco a seguirti....
Riprendo l'esempio riportato da TopFuel:
DIM array(5 TO 20) AS STRING
Voglio dire che, anche in un caso come questo, è evidente che, di qualunque quantità siano stati incrementati gli elementi di un array non-definito, il programmatore già sa a priori (e l'ha impostato appunto nel codice) che deve andare a leggere i valori contenuti dal 5° al 20° elemento. L'array, in sostanza, dovrà essere comunque di almeno 21 elementi.
Ma questo si può fare, come ho ampiamente dimostrato prima, agevolmente anche con Gambas.
Le azioni fondamentali che si possono svolgere sugli elementi di un array sono, come è noto e palese, riempimento con dei valori, del tipo per i quali tali elementi sono stati definiti, e lettura dei valori presenti.
Riguardo alla fase di assegnazione dei valori ad uno o più elementi dell'array mi sembra che, assegnare valori - ad esempio - dal 5° al 20° elemento, lasci pensare che:
* sono stati già comunque definiti almeno 21 elementi dell'array;
* gli elementi dall'indice 0 all'indice 3, non essendo interessati da alcuna assegnazione, continueranno a possedere valore zero.
E' dunque evidente che l'aver deciso di lasciare vacanti quei quattro primi elementi è stato determinato - qualunque essa sia - da una motivazione.
In Gambas potrei fare avere due casi, e risolvere agevolmente la cosa a seconda del verificarsi di questi:
* array di dimensione definita:
Public Sub Form_Open()
Dim ss As New String[21]
Dim j As Byte
For j = 5 To 20
ss[j] = "alibaba"
Next
' oppure:
For j = 5 To 20
ss.Add("alibaba", j)
Next
End
* per un array di dimensione indefinita, quell'esempio di TopFuel non è più conferente, giacché mi pare vada da sé che una definizione da un elemento ad un altro dell'array presuppone una definizione a priori degli elementi almeno minimi dell'array medesimo (come ho anche detto all'inizio).... altrimenti come potremmo parlare di 20° elemento ?
Insomma, mi sembra che VB faccia un lavoro preventivo, che invece in gambas devi svolgere espressamente tu con il codice.
Ora che siamo d'accordo sulla maniera di considerare il puntamento sui singoli elementi di un array (quando cominciai a studiarli si usava l'italiano e si chiamavano, perciò, tabelle), vediamo come potere gestire artigianalmente l'opzione "option base=1" di VB.
Vorrei considerare tre casi possibili di dichiarazione:
Dim ArrayUniDim As New String[11]
Dim ArrayBiDim As New String[11, 3]
Dim ArrayDinamico As New String[ ]
La soluzione è semplice e valida per tutti i tipi di array. I primi due esempi permettono di potere scrivere istruzioni di caricamento come le seguenti:
For i = 1 to 11 'trascurando pertanto l'elemento con indice=0
ArrayUniDim[i] = Str(i)
Next
For i = 1 to 11 'trascurando anche in questo caso l'elemento con indice=0
ArrayBiDim[i,1] = Str(i)
ArrayBiDim[i,2] = Str(i)
Next
Diverso è il caso degli array dinamici, che per loro natura, hanno una dimensione imprecisata, dipendente dal numero effettivo degli elementi che risulteranno caricati solo alla fine del caricamento stesso.
Per essi occorre eseguire fra le prime istruzioni della procedura, allo scopo di non dimenticarlo, un caricamento speciale, quello di un elemento vuoto:
Tutti i caricamenti successivi potranno avvenire con:
For i = 1 to 11 'trascurando pertanto l'elemento con indice=0
ArrayDinamico.Add(Str(i))
Next
Ci sarebbe ancora da considerare il tipo di array dinamici, pluridimensionali. Essi tuttavia possono essere gestiti come l'ArrayBiDim del secondo esempio:
Dim iDimens as integer
Dim ArrayBiDinamico As New String[iDimens,2 ] 'è dinamico perchè la sua dimensione dipende dal valore numerico contenuto in iDimens
iDimens=Int(Val(TextBox1.Text)) + 1 'la somma di 1 permetterà di trascurare successivamente l'elemento con indice 0
For i = 1 to iDimens
ArrayBiDinamico[i,1] = Str(i)
ArrayBiDinamico[i,2] = Str(i)
Next
Spero di essere stato di aiuto per chi volesse utilizzare in Gambas la tacnica gestita in via automatica in VB. Personalmente penso che il gioco non valga la candela. Secondo me basta abituarsi a gestire come 1° elemento l'elemento con indice 0(zero) ed una volta fatta propria tale modalità di gestione degli array, il futuro diventerà più semplice. :D
:ciao: