Dim ArrayUnaDimensione as new string[]
Dim ArrayDueDimensioni as new string[RR, C]
' Classe [b]TrattaTabDueD[/b]
Public iIndTabDueD As Integer
Static Public iTotElTabDueD As Integer
Static Public $TabDueD As New String[iTotElTabDueD + 1, 7]
Public Sub _new(i_CoVoConCas As Integer, i_DataContPri As Integer, fImport As Float, $_NmCreDeb As String, i_CoVoContrPart As Integer, $DataCont As String, $_SwPreMom As String, i_DtCoUltPreMom As Integer)
If iTotElTabDueD = 0 Then
iIndTabDueD -= 1
Endif
'---------- bla ------ bla ------ bla ----------
If iIndTabDueD = (-1) Then
iTotCar = AccodElemNuo(iTotCar, i_DataContPri, fImport, $_SwPreMom, $_NmCreDeb, i_CoVoContrPart, $_TipoPreMom, i_DtCoUltPreMom)
Else
bTrovato = TrovElemTabDueD(i_DataContPri, $_NmCreDeb, fImport, $_TipoPreMom)
If Not bTrovato
iTotCar = AccodElemNuo(iTotCar, i_DataContPri, fImport, $_SwPreMom, $_NmCreDeb, i_CoVoContrPart, $_TipoPreMom, i_DtCoUltPreMom)
Endif
Endif
'---------- bla ------ bla ------ bla ----------
END
Public Function AccodElemNuo(iTotCar As Integer, i_DataContPri As Integer, fImport As Float, $_SwPreMom As String, $_NmCreDeb As String, i_CoVoContrPart As Integer, $_TipoPreMom As String, i_DtCoUltPreMom As Integer) As Integer
Dim i As Integer
Dim iConta As Integer
Dim ind1 As Integer
Dim ind2 As Integer
Dim $Credito As String
Dim $Debito As String
Dim $StriPreMom As String
Dim $TabUniD As New String[]
'----------------------------------------------------------------------------------------------------------------------------------------------
If iTotElTabDueD > 0
For i = 0 To iTotElTabDueD - 1
$TabUniD.Add("§" & $TabDueD[i, 0] & "§" & $TabDueD[i, 1] & "§" & $TabDueD[i, 2] & "§" & $TabDueD[i, 3] & "§" & $TabDueD[i, 4] & "§" & $TabDueD[i, 5] & "§" & $TabDueD[i, 6])
Next
Endif
If fImport >= 0 Then
$Debito = CFloat(fImport)
$Credito = 0
Else
$Debito = 0
$Credito = CFloat(fImport)
Endif
$TabUniD.Add("§" & (Str(i_DataContPri)) & "§" & $Credito & "§" & $Debito & "§" & (UCase($_TipoPreMom)) & "§" & $_NmCreDeb & "§" & (Str(i_CoVoContrPart)) & "§" & (Str(i_DtCoUltPreMom)) & "§")
Inc iTotElTabDueD
$TabUniD.Sort
For i = 0 To iTotElTabDueD - 1
$StriPreMom &= $TabUniD[i]
Next
$TabUniD.Clear
$TabUniD = Split($StriPreMom, "§", "\r\n", True)
iConta = $TabUniD.Count - 1
For i = 0 To iConta
$TabUniD[i] = Replace($TabUniD[i], Chr(34), ")")
Next
$TabDueD = New String[iTotElTabDueD, 7]
i = 0
ind1 = 0
For i = 0 To iTotElTabDueD - 1
For ind2 = 0 To 6
$TabDueD[i, ind2] = $TabUniD[ind1]
Inc ind1
Next
Next
End
DIM aResult AS NEW String[][12] ' Una matrice di matrici di stringhe!
Può darsi che l'utilizzo che tu mi inviti a ristudiare sia più felice di quello messo in pratica da me, ma non è ancora alla mia portata.In informatica si può raggiungere lo stesso obiettivo attraverso strade diverse, e non è detto che nel mio suggerimento sia inclusa la bibbia. Quello che intendevo è che possono esserci altre strade, ovviamente in base alle proprie conoscenze del linguaggio. I tuoi studi e test hanno avuto proprio l'obiettivo di trovarne una di strada, io ho solo messo il carico da 11, presupponendo altre, ovviamente basate sulla mia esperienza con gambas.
sulle mie spalle grava sempre la lacuna del "C"In realtà, la poca esperienza non è causata dal C. Sicuramente condiziona la mente nel conoscere più a fondo cosa vuol dire programmare, e prendere la strada migliore per risolvere i problemi. Ma quello che soprattutto permette di elaborare certi concetti è solo l'esperienza, fatta su svariati campi e con svariati linguaggi software, partendo dal linguaggio assembre su antichi processori. Io ho avuto la fortuna di lavorare per parecchi anni in vari ambienti, dal controllo dei satelliti, a quello di impianti meccanici, telecomunicazioni, fino alla creazione di gestionali, e l'uso di svariati motori di database. Molte delle problematiche che riscontro sono provocati dalle stesse cause, sia che si tratti di un programma Asm, sia che si tratti di Gambas (un esempio...).
In realtà, la poca esperienza non è causata dal C. Sicuramente condiziona la mente nel conoscere più a fondo cosa vuol dire programmare, e prendere la strada migliore per risolvere i problemi. Ma quello che soprattutto permette di elaborare certi concetti è solo l'esperienza, fatta su svariati campi e con svariati linguaggi software, partendo dal linguaggio assembre su antichi processori. Io ho avuto la fortuna di lavorare per parecchi anni in vari ambienti, dal controllo dei satelliti, a quello di impianti meccanici, telecomunicazioni, fino alla creazione di gestionali, e l'uso di svariati motori di database. Molte delle problematiche che riscontro sono provocati dalle stesse cause, sia che si tratti di un programma Asm, sia che si tratti di Gambas (un esempio...).Nel mio piccolo, anch'io ho tanta esperienza, ma solamente a livello di programmi applicativi e sempre dentro lo stesso buco aziendale. Conosco l'assembler perchè l'ho usato all'inizio della mia carriera (ricordo, e spero di non sbagliarmi, che fosse l'APS dell'Honeywell). Ho studiato il metodo di archiviazione dati nella struttura DB, ma non ho mai programmato in tali ambienti prima di conoscere Gambas, perchè, negli ultimi anni della mia carriera, ho dismesso l'abito del programmatore per indossare quello di analista di ambienti applicativi IBM. Ho dovuto perciò conoscere la logica gestionale dei DB. Ciò però sempre rivolto ad elaboratori di tipo Main Frame.
.... cercando al contempo di educare con concetti che spingano a far lavorare la logica, la fantasia e soprattutto le "mani" sulla tastiera. Non sono propenso a facili soluzioni, perchè a mio avviso non insegnano e forniscono solo la "pappa pronta". Come a volte mi puntualizza il caro vuott, quando rispondo ad alcuni post che hanno queste caratteristiche, ovvero cercare di avere solo i risultati senza sapere come è il procedimento per raggiungerli... :D
.... cercando al contempo di educare con concetti che spingano a far lavorare la logica, la fantasia e soprattutto le "mani" sulla tastiera. Non sono propenso a facili soluzioni, perchè a mio avviso non insegnano e forniscono solo la "pappa pronta". Come a volte mi puntualizza il caro vuott, quando rispondo ad alcuni post che hanno queste caratteristiche, ovvero cercare di avere solo i risultati senza sapere come è il procedimento per raggiungerli... :D
md9327 è stato sempre fedele e coerente in effetti con questa sua pedagogia.
DIM pippo AS PgConfigGroup = PgConfigGroup("xyz","zyx")
...
altrimenti
...
DIM pippo AS New PgConfigGroup("xyz","zyx")
E' sottinteso che, se una logica non viene capita, o intesa male, è giusto chiedere in relazione ai dubbi che uno ha, magari chiedendo anche un esempio concreto. E' anche ovvio che non si può chiedere di risolvere completamente un'idea, fornendo pure il codice completo.
Quello che tento di fare, o di divulgare, è che per raggiungere un fine/scopo in informatica le strade possono essere molteplici.
Io posso fornire, a seconda delle mie conoscenze, fatte poi sul campo e sulla mia pelle, spunti e idee per risolvere un dato quesito, o fornire lumi per quanto riguarda un determinato comporamento di un componente e/o metodo, ma la cosa, secondo me, deve terminare lì...
Stà poi al richiedente, sviluppare quanto appreso, provando e riprovando, e magari riporre un'ulteriore quesito, ma in questo caso più mirato.
Devo anche dire che io non mi esprimo molto bene, e a volte certi concetti non riesco a spiegarli tali da renderli comprensibili a tutti. Non è perchè io sono un guru, ci mancherebbe... ma è che mi esprimo più con i fatti.
Molte delle conoscenze ed esperienze fatte, a parte anche con altri linguaggi, con gambas, sono inclusi e concentrati nei miei progetti. Ed è per questo che invito sempre a scaricare i miei programmi, che hanno lo scopo principale di sviluppare il più possibile quanto offre gambas.
Allora, non per smontare il tuo bel lavoro di studio, ma gli array multidimensionali si possono fare, anche se in modo diverso da come hai tentato di fare.
E' vero che gli array di base String[], Integer[], ecc. hanno la possibilità di essere creati come array multimensionali, ma si può fare anche in altro modo, ovvero usando i Variant.
Il Variant è un oggetto che può contenere valori di diverso tipo. La tipologia dei valori può essere diversa anche tra i valori nella stessa colonna, ma ad ogni modo il concetto che vado a descrivere è quello dell'uso con la multimensionalità.
Anche per il Variant esiste un oggetto array, appunto Variant[], che non è altro che un array di valori di vario tipo. Però, dato che il Variant stesso può contenere un array come valore unico, l'utilità è puramente estetica.
Ad ogni modo, mettiamo di voler memorizzare una serie di numeri (potrebbero essere stringhe, ma il concetto è lo stesso...).
A questo punto andiamo a creare una array Variant[] che, come da sintassi Gambas, può essere creato vuoto, quindi senza alcun elemento.
Mettiamo di voler creare un array bidimensionale (il concetto poi si può propagare all'infinito...), contenente appunto una serie di numeri.
Dato che l'array multidimensionale, per come è fatto, ha come indice solamente la posizione del valore interno all'array, ogni elemento và indirizzato con la proprietà Index (comune a tutti gli array). L'aggiunta di elementi può essere fatta con il metodo Add(), oppure con il metodo Insert() (quest'ultimo ha la possibilità di inserire elementi in un punto specifico, non appeso alla fine dell'array come di default).
In questo modo avremo un'array di numeri, molto simile ad un'array di Integer[] (ad esempio...).
Mettiamo di voler invece creare un'array con un ulteriore livello.
Per fare questo è sufficiente creare un'array Variant[] in ogni elemento dell'array padre: <Variant[]>.Add(<Variant[]>).
Questa logica può essere applicata all'infinito.
L'unico neo di questo metodo, è che se si và a modificare in runtime la struttura di un'array multidimensionale, potremmo avere elementi con numero di colonne non allineate, ovvero ad esempio, avere l'elemento 0 con un valore, e l'elemento 1 con 3/3 valori.
In questo caso, non sono stati previsti metodi per compensare un disallineamento di questo tipo, e si dovrà ricorrere per forza ad una funzione apposita, o derivare la classe array in un nuovo oggetto/classe che ha la funzione appropriata.
Per costruire questo tipo di funzione, si dovrà tener conto: 1) del numero di dimensioni, 2) del numero di elementi. Questo perchè qualsiasi tipo di elaborazione potrebbe inficiare sulla velocità di esecuzione della nostra applicazione.
Ad ogni modo, creare una funzione di questo tipo è relativamente semplice, perchè sarà necessario e sufficiente ciclare in tutte le dimensioni dell'array, dimensionando opportunamente i sotto elementi con il corretto numero di colonne, magari impostando le colonne aggiunte con valori di default, mentre eventuali colonne eliminate verranno perse.
Un oggetto di questo tipo, derivato da un'array base (ricordo INHERITS), dovrà avere proprietà interne apposite per i contatori delle varie dimensioni e, usandoli appunto come Property, creare proprio all'interno dei metodi relativi il codice per ridimensionare opportunamente l'array.
Spero di aver chiarito i concetti sulla creazione e l'uso degli array multidimensionali, facendo al contempo i miei complimenti per gli studi fatti da picavbg che, come ho notato più volte, ci mette davvero la testa per affrontare ogni problema che incontra, e che rende sempre pubblici i suoi sforzi. Spero che quanto da me sopra scritto, ti fornisca qualche elemento in più... :ok:
Ciao
Dim MyArray as new Variant[]
Dim i, x as integer
Dim y as float
Dim p as string
p = 'arriva da un ciclo
x = 'arriva da un'altra variabile
y = 'arriva da un'altra variabile
for i = 0 to 25
MyArray.add(p, i, x, y) 'qui non riesco a capire come caricare i dati
next
Codice: [Seleziona]for i = 0 to 25
MyArray.add(p, i, x, y) 'qui non riesco a capire come caricare i dati
next
Codice: [Seleziona]for i = 0 to 25
MyArray.add(p, i, x, y) 'qui non riesco a capire come caricare i dati
next
...ovviamente devi andare ad individuare ogni singolo... nodo della rete righe/colonne. Puoi vedere qui
http://www.gambas-it.org/wiki/index.php?title=Matrici_ed_Array_multidimensionali_definiti
degli esempi (anche se con matrici a dimensioni definite). Poiché la tua matrice non ha una quantità di elementi definiti, per farne aumentare appunto la quantità proporrei uno sguardo anche a quest'altra pagina:
http://www.gambas-it.org/wiki/index.php?title=Array_dinamici_%E2%80%93_creazione_e_riempimento
Trattandosi, da quel che vedo, di valori di tipo differente, potresti anche utilizzare una Struttura con campi vettoriali:
http://www.gambas-it.org/wiki/index.php?title=Strutture:_dichiarazione_ed_uso#Strutture_contenenti_Vettori_e_Matrici