INHERITS class

[md9327]

Apro questa discussione, più per informazione a chi può servire che altro.
Qualche mese fà, in uno scambio di mail, Benoit mi aveva confermato che il massimo numero di inerenze, ovvero derivazioni annidate delle classi, aveva un limite imposto di massimo 8.
Da test che stò effettuando in questi giorni per una mia applicazione, ho notato che questo limite non è più quello indicato ma và oltre. Non ho avuto modo di provare fino a che punto è possibile arrivare, ma già con una dozzina di classi annidate tra loro sembra funzionare tutto alla grande, senza alcun problema di ritardi o altro.

[g.paolo]

Effettivamente tu voli molto in alto rispetto a me, che anche se ho capito cosa può essere una classe( o almeno lo spero) non mi sognerei mai di pensare che le classi possano essere annidate!
Sapevo che non si avrà mai finito di imparare, perchè ogni giorno sorgono cose nuove, ma ancora una volta capisco d'essere molto ma molto lontano dalla conoscenza che si addice ad un seppur modesto programmatore!

[md9327]

Finchè è possibile, io cerco di condividere quello che scopro e che sò riguardo una determinata cosa; nello stesso modo ringrazio quelli che fanno lo stesso, e da cui attingo per incrementare le mie conoscenze.
Non sò tu, ma io ci lavoro costantemente anzi, è la mia principale attività, e mi piace conoscere sempre cose nuove. Purtroppo non si può stare dietro a tutto, e a volte mi accorgo che non approfondisco le cose fino ad arrivare a diventare un massimo esperto di una cosa; tutto ciò perchè mi piace passare oltre. Ovviamente, e riguardo Gambas, dato che ho buttato giù un paio di applicazioni per provare questo linguaggio, mi piace anche capire fino a che punto si può arrivare, e quindi sperimentando provo a vedere sempre più cose. Altrettanto ovviamente ci metto la mia esperienza e il fatto pure che ci lavoro attualmente, la cosa aiuta non poco.
Tutto qui...
Mi fà piacere che qualcuno possa usufruire di questo, e magari possa pure offrire in modo altrettanto altruistico le sue esperienze che potrebbero, oltre ad allargare le proprie, espanderle anche ad altri.

In riferimento a Gambas, ho avuto modo di constatare e provare molte cose (grazie all'open-source e a Linux), però purtroppo non sempre riesco a racimolare un pochino di tempo e le idee per scrivere due righe su un argomento.
In questo e in pochi altri casi l'ho fatto, e spero possa essere utile.

Ciao

[g.paolo]

Lo spirito che muove l'open-source è una cosa fantastica, direi quasi aliena. In questo mondo in cui nulla si fa se non c'è di mezzo uno scopo venale, questo spirito è qualcosa di unico ed incredibile!
E' bello sapere che ci sono ancora persone disposte a mettere a disposizione le loro conoscenze per aiutare quelli che non ci arrivano, non è un atteggiamento molto "popolare" direi, ma senza dubbio encomiabile.
Mi sono sentito sempre mosso da questo spirito, ed ho sempre aiutato chiunque se mi era possibile, ma mai avrei pensato di incontrare miei "simili" all'interno di questi forum o vorrei dire "comunità virtuali".
Non dispongo della tua conoscenza di programmatore, perchè la mia attività non è mai stata quella ed il programmare è sempre stato per me una specie di gioco in cui   si prova a mettere le redini ad un computer per fargli fare quello che desideri.
Ma per quanto sia limitata la mia preparazione, cercherò sempre di metterla a disposizione di chi si troverà in difficoltà.
Ora, se vorrai spiegarmi brevemente cosa intendi con il termine di "classi annidate", te ne sarò ulteriormente grato.
Ciao.

[md9327]

Eheheh, a domanda cercherò di rispondere, anche se per una spiegazione esauriente ci vorrebbe più tempo e spazio.
Devo dirti che a suo tempo, di classi e oggetti, non erano neanche nell'anticamera del cervello di nessuno, e io ho iniziato a sperimentarlo su un linguaggio che all'epoca aveva appena iniziato ad abbozzare qualcosa del genere... Clipper... Programmavo già in C/C++ da svariati anni, e il Clipper lo usavo solo per i gestionali per alcuni clienti.
Prima di parlare di inerenza o annidazione, si dovrebbe parlare prima di cosa sono le classi o gli oggetti in genere. Comunque, ipotizza una bottiglietta di plastica, tipo quelle che vendono per l'acqua (es. Egeria)... ipotizza una classe che descriva la bottiglia nei suoi elementi essenziali, del tipo forma e/o colore. Ipotizza ora tu voglia creare una bottiglietta che abbia come caratteristiche di base quelle della classe precedente, es. il colore verde, però alla seconda bottiglietta devi aggiungere l'etichetta... a questo punto crei una seconda classe (o oggetto), che eredita tutte le caratteristiche della prima classe, ma aggiunge anche un proprietà "etichetta".
Ora vuoi personalizzare una serie di bottigliette, ognuna con etichetta diversa, che fai? Crei un terzo oggetto, che eredita le caratteristiche della seconda classe (quella con l'etichetta), ma su questa ci appone una scritta personalizzata.
Il sunto di tutto questo discorso? E' che gli oggetti (o classi) derivate, ereditano di norma tute le caratteristiche delle classi padre, per cui non devi riscriverne le proprietà, ma aggiungerne solo alcune che personalizzano quest'ultima classe; inoltre, un'eventuale modifica, o variazione, delle proprietà nelle classi padri, si rifletteranno di conseguenza in quelle derivate.

Spiegato bene?
Se ti sei appisolato, allora vuol dire che ti ho annoiato... :-)

Scherzi a parte, se hai qualche dubbio, puoi chiedere...

Bye

[g.paolo]

Invece ho capito tutto e perfettamente credo!
Lo sapevo io che potevo contare su di te.
Pertanto se ho capito bene ci si puo fare una classe iniziale che puo essere il bisnonno, poi una erede che chiameremo nonno, ed un'altra padre, ed infine una figlio.
E' evidente che l'ultima, quella figlio sarà la più ricca di proprietà, perchè oltre a quelle ereditate ne avrà di proprie.
Capito bene?

[md9327]

YES!

In altri linguaggi, ad esempio il C++, è possibile ereditare da più padri diversi (come nella realtà... :-) ). Questo permette di avere delle sottoclassi molto potenti e molto particolari.
Il giochetto viene molto usato in questi linguaggi, ma al momento Gambas non è ancora in grado di fare queste cose... chissà, un domani...
Inoltre, ma non in tutti i linguaggi, è possibile nascondere alcune proprietà ai figli, in modo che solo il padre ne abbia il completo controllo; ora non mi vengono in mente esempi pratici, ma ti assicuro che anche questa è normale prassi.

Comunque, meno male che non ti addormentato, vuol dire che in qualche modo spiego bene... :-)

[g.paolo]

No tranquillo, non mi hai addormentato, perchè hai spiegato in modo "commestibile" e non come certi politici.....(.....velo pietoso!)
La capacità di spiegare bene ritengo sia data principalmente dalla padronanza dell'argomento, e poi dalla capacità di mettersi nei panni degli altri, degli ignoranti.
Tu non hai certo questo tipo di difficoltà, e come ho potuto notare, hai anche la lodevole capacità di ammettere un'eventuale scarsa conoscenza di un determinato problema, cosa che non tutti riescono a fare!
Grazie di nuovo!

[g.paolo]

Continuando sull'argomento "classi" ti dirò che il mi primo approccio con le medesime non è stato molto proficuo.
Praticamente ho creato una funzione di impiego generale da poter portare in altri progetti e pensavo che la classe fosse quindi il posto giusto dove metterla.
Ma se io la metto in un modulo di classe dichiarandola PUBLIC e nel progetto la richiamo con il costrutto "modulodiclasse.funzione(parametri)" ottengo immediatamente un errore del tipo: "is not static"!
In che senso dunque non è statica, e perchè dovrebbe esserlo visto che ho bisogno di richiamarla "pubblicamente"?
A quanto pare non funziona allo stesso modo dei "moduli" che utilizzo per funzioni pubbliche specifiche del progetto.
Mi potresti spiegare l'arcano? Grazie.

[md9327]

Se ho capito bene, la cosa mi pare strana...
A parte che in Gambas, il concetto di modulo è in definitiva una sottospecie di classe, tranne che non esistono proprietà ma solo metodi, e questi ultimi non sono altro, come hai giustamente scritto e usato, che funzioni a cui fare riferimento tramite il prefisso del modulo che le contiene.
Visto il giochetto, per quanto mi riguarda, io uso esclusivamente classi, e se devo creare funzionalità generiche all'interno di un'applicazione, definisco i metodi di queste classi come STATIC, per cui posso richiamarle senza dover creare un'apposita istanza.
L'unico modulo che utilizzo è quello di partenza, ovvero la Main, che contiene la routine di partenza con cui definisco alcune caratteristiche per il lancio successivo dell'applicazione vera e propria; un esempio è quello della definizione della lingua, oppure la lettura di alcune proprietà che mi serviranno ad impostare l'applicazione.
A volte uso questo modulo anche per la fase di debug, creando alcune piccole funzioncine che lancio per fare determinate cose (es. la creazione di un file di configurazione di partenza, ecc.).

Ad ogni modo, dato che Gambas in compilazione ti restituisce quel tipo di errore, prova a seguire le sue indicazioni, anteponendo STATIC nella dichiarazioni delle funzioni. Devi stare comunque attento all'utilizzo di riferimenti ad oggetti, che magari potrebbero ancora non essere stati creati, oppure a variabili non ancora inizializzate... Insomma, un'analisi un pochino approfondita non fà male...

Un consiglio: non fidarti completamente del compilatore, la sua è un'opera di assemblaggio iniziale ed essendo un linguaggio interpretato, lascia molto al programmatore il compito di verificare il codice, e non evita di incorrere in problemi durante l'esecuzione. In parole povere, "sò cavoli tuoi se poi và in crash"... Diciamo che, nelle procedure di creazione di un eseguibile, è molto diverso e limitato rispetto ad altri linguaggi a basso livello, anche se d'altro canto anche in questi devi occuparti di ben altre cose ed altri problemi.

[g.paolo]

Ho capito dunque che la cosa non è del tutto "lineare" e non sempre ci si deve fidare sulla qualità dei messaggi di debug.
Proverò allora ad effettuare delle prove cercando prima di approfondire meglio le differemze sostanziali nelle dichiarazioni delle variabili e funzioni.
Ti saprò dire come è andata.

[leo72]

Il problema riscontrato dipende da come Gambas "costruisce" gli oggetti di tipo Class.
Per distinguere fra una classe di tipo statica ed una di tipo dinamica adotta un sistema al tempo stesso semplice e stupido.
Si tratta di inserire nella classe il metodo _New() e di fare un assegnamento di variabile qualsiasi all'interno di questo metodo in modo tale da far capire a Gambas che la classe può essere ineritata. Esempio di codice:

Codice: [Seleziona]

' Gambas class file

PRIVATE Variabile as Integer

PUBLIC SUB _new()
  Variabile = 1
END SUB

Ovviamente l'assegnazione può interessare una variabile realmente usata: ad esempio azzerare un eventuale contatore utilizzato da qualche altra parte.
Se Gambas non trova il metodo _New() assume che la classe sia statica e non può quindi ineritare nuove classi, non si può cioè scrivere del codice come il seguente in un form:

Codice: [Seleziona]

PUBLIC SUB Metodo_qualsiasi()
DIM cMiaClasse AS New MiaClasse
  ....
END SUB

[g.paolo]

@leo
Non so quindi se ho fatto bene a costruire una funzione di classe in questo modo, ma a quanto pare funziona, e non mi sono posto altri problemi.
Ma siccome sono un po curioso per natura, mi piacerebbe sapere il tuo parere in merito.
Questa funzione inserita in una classe mi serve per popolare tutte le combo nei diversi form

Codice: [Seleziona]

STATIC PUBLIC FUNCTION popola_combo(cbx AS ComboBox, campo AS String, comando AS String)
'cbx=nomecombo - campo=nomedicampotabella - comando=comandoselect
    DIM res_popola_combo AS Result
    DIM totrecords AS Integer
    DIM contatore AS Integer 
    DIM connessione AS NEW Connection
    WITH connessione
        .Name = Avvio.cartellaDB & Avvio.nomeDB 
        .Type = "sqlite3" 
        .Open
        res_popola_combo = .Exec(comando)        
    END WITH 
    WITH res_popola_combo
        totrecords = .Count - 1
        FOR contatore = 0 TO totrecords
            .MoveTo(contatore)
            cbx.Add(res_popola_combo[campo])
        NEXT
    END WITH 
CATCH 
    Message.Error(Error.Text)
    connessione.Close
END 

[md9327]

Per rispondere a leo: in realtà, sul concetto di _new(), credo di doverti dar torto, perchè faccio spesso uso di classi INHERITS (tanto per parlare a comandi...), e non sempre ho bisogno di includere il metodo _new(). Se dai un'occhiata alla classe Application, questa è concettualmente una classe STATIC (tutta, tutti i metodi e le proprità), ma può essere tranquillamente ereditata; la definizione di una classe ereditabile o meno dipende da come è stata costruita nel linguaggio con cui è costruito Gambas (il C++). A quanto mi risulta, con Gambas non è possibile creare classi NON INHERITS.
E' comunque valido il concetto, descritto nella doc ufficiale che, se si parametrizza una classe, gli oggetti che ne derivano ereditano forzatamente anche i parametri della classe padre, ma è possibile implementarle aggiungendone di ulteriori; la lettura dei parametri avviene da sinistra a destra, non è necessario elencare quelli già definiti nelle classi padre (anzi, non si devono ridefinire), e l'esecuzione avviene iniziandi dalla prima classe in ordine gerarchico (la prima, ovvero il Parent, ossia il bisnonno...).

Per rispondere a darth: ad occhio la tua funzione dovrebbe funzionare, ma il problema stà sul fatto che tu cerchi di creare un oggetto dinamico (la Connection) dentro una classe statica; il compilatore dovrebbe darti un errore. In quanto alla funzione in se stessa, anche senza STATIC, dovrebbe poter funzionare, se chiamata da ruoutine esterne (cosa non vera se la dchiari PRIVATE, ovviamente). Come avevo accennato nel precedente post, devi fare attenzione a non mischiare dinamico e statico, perchè giustamente gambas non lo permette; le variabili usate nelle routine statiche devo essere variabili base (es. Integer o String) e mai variabili che generano strutture come oggetti. Se possibile, usare i parametri per passare i riferimenti ad oggetti creati dalle procedure chiamanti; ricorda che gli oggetti possono essere modificati da queste funzioni generiche, e le routine chiamanti se li troveranno modificati di conseguenza. Questo non è vero per le variabili di base.

[g.paolo]

@md9327
Infatti la funzione "funziona" senza errori di sorta, ma se tolgo lo STATIC si pianta con l'errore che ho detto.
Il fatto che all'interno io cerchi di dichiarare una connessione locale non mi da errore, forse perchè (e lo dico da ignorante) la medesima connessione nasce e muore al suo interno.
Se le cose non stanno così, allora proprio non so come faccia a funzionare!
A proposito: mi ero dimenticato la chiusura della connessione prima del CATCH.