Metodi nascosti: New() e Free()

Da Gambas-it.org - Wikipedia.
Versione del 22 ago 2025 alle 08:35 di Vuott (discussione | contributi)
(diff) ← Versione meno recente | Versione attuale (diff) | Versione più recente → (diff)
Vai alla navigazione Vai alla ricerca

Ogni Oggetto ha alcuni Metodi che possono essere utilizzati tranquillamente, e che corrispondono a precise fasi della vita dell'Oggetto medesimo. [nota 1]

In Gambas, per tutti gli Oggetti base, sono presenti alcuni Metodi, che di norma non vengono presi in considerazione e che, in effetti, non vengono neppure dichiarati durante la costruzione di un Oggetto.
Dato che ogni Oggetto deriva in ogni caso dalla Classe base Object di Gambas, anche queste Proprietà nascoste vengono definite nelle nuove sotto-Classi.
L'utilità di questi Metodi è enorme, dato che tramite queste è possibile modificare le proprietà di base dell'oggetto stesso, passare parametri, definire condizioni di funzionamento, chiudere file aperti, rilasciare risorse, ecc. Questa particolarità è inclusa sia nelle Classi dinamiche che in quelle statiche.

I Metodi nascosti più importanti, sono: 

Public Sub _new()

e 

Public Sub _free()

rispettivamente:

  • _new(): creazione dell'oggetto;
  • _free(): distruzione dell'oggetto;
  • _new() può essere usato per passare dei parametri all'oggetto, proprio nella fase di creazione (non di apertura), e può essere utilizzato anche per creare oggetti all'interno di una Form.
  • _free() viene chiamato giusto nella fase finale di eliminazione dell'oggetto dalla memoria. Può essere utilizzato, ad esempio, per terminare un timer (se si verifica un errore), oppure per chiudere un'attività, a prescindere dal resto.

Queste due funzioni, dunque, sono sempre e comunque chiamate (indipendentemente se dichiarate esplicitamente nel codice o meno) da Gambas, quando l'oggetto viene creato e distrutto, anche se non sono presenti nel codice dell'oggetto, perché esistono comunque nella classe base di tutti gli oggetti creati in Gambas (Object ).

L'Oggetto deve essere esplicitamente creato, ovvero fornita sufficiente memoria per contenerlo, poi deve essere chiamato il suo costruttore. In Gambas questo procedimento è implicito con l'uso dell'istruzione NEW. Tale istruzione, infatti, provoca prima la creazione in memoria dell'Oggetto, poi esegue il suo costruttore, in tutti i casi il metodo nascosto "_new()".

Inoltre, ogni oggetto prevede anche un metodo distruttore, che in gambas viene assunto da un altro metodo nascosto _free().
Gambas infine chiama automaticamente "_free()" e "_delete()", quando l'Oggetto non viene più usato.


_new() - Il Costruttore

Il Costruttore "_New()" è un Metodo nascosto che viene eseguito al momento della costruzione dell'Oggetto (come fosse un Evento speciale della Classe a cui appartiene).
Esso può ricevere argomenti passati all'atto della creazione dell'Oggetto della Classe specifica mediante la parola-chiave "New". [nota 2]

Come già detto, il Metodo nascosto _New() si comporta come un Evento: esso - se previsto in codice - si solleva all'atto della creazione di una Classe.
In esso si possono definire e impostare i valori base e le proprietà dell'Oggetto, e questo anche se è un Oggetto grafico (es. una Form ).

L'istruzione "_new()" viene sempre eseguita, sia negli oggetti statici, che negli altri, solo che verrà eseguita esclusivamente alla prima chiamata di un qualsiasi loro Metodo.

Per fare un esempio, la classe Form non accetta di norma alcun parametro, ma vediamo come è possibile modificare questa impostazione in modo tale, ad esempio, da potergli passare un array di stringhe:

Creiamo una Form, e apriamo l'editor di testo per modificare il codice della Form, e scriviamo le istruzioni seguenti: 

 PRIVATE $arr AS String[]
 ...
 ...
 PUBLIC SUB _new( arr AS String[] )
   ...
   $arr = arr
   ...  
 END

Cosa abbiamo ottenuto? Bè, nulla di particolare... abbiamo solo detto a Gambas che la Form ora accetta un parametro, di tipo String[] !

Questa possibilità è solo permessa attraverso questo metodo nascosto, altrimenti la cosa non sarebbe stata fattibile, se non attraverso metodi poco ortodossi (come, ad esempio, delle variabili globali), e questo permette di condizionare enormemente un oggetto. Se, come da esempio, salviamo il parametro in una variabile privata della classe (nell'esempio: $arr), possiamo poi gestire i suoi dati all'interno della classe, modificarli e, magari restituirli alla chiusura della Form. Un'altra ottima caratteristica di questo metodo, è il fatto che il suddetto viene sempre e comunque invocato alla creazione della classe, prima di qualunque altro, per cui rende possibile condizionare totalmente la gestione della classe stessa; nessun evento e nessun'altra funzione sarà chiamata o attivata, se non dopo l'esecuzione del Metodo nascosto "_new()" (il Costruttore!). [nota 3]

Non esistono limitazioni sulla posizione del metodo all'interno del codice, ma, se presente, verrà comunque invocato.

L'unica cosa da tener presente è che, data l'inerenza dalla classe base Object, e da eventuali altre, verranno chiamati prima i metodi _new() delle classi superiori, partendo da quella più in alto, fino ad arrivare alla nostra (come per l'esempio). Eventuali parametri, già previsti nelle classi superiori, verranno caricati prima di quelli della nostra classe. E' anche da ricordare che l'elenco dei parametri passati alla nostra classe deve comprendere anche quelli delle classi superiori, e il loro posizionamento deve seguire la logica: da destra verso sinistra, ovvero la prima che sarà letta e utilizzata è la prima a destra.

Come esempio, costruiamo una classe MyButton, derivata dalla classe base Button di Gambas.

Tramite l'IDE di Gambas, creiamo una classe MyButton, quindi apriamo l'editor per modificarne il codice: 

 INHERITS Button
 ...
 PUBLIC SUB _new( etichetta AS String )  'passiamo l'etichetta che verrà impostata come testo del pulsante
   ...
   WITH ME
     .Text = etichetta
   END WITH
   ...
 END

A questo punto, per utilizzare l'oggetto MyButton, è necessario il codice seguente: 

 PUBLIC SUB CreaMyButton()
   ...
   DIM MyBtn AS MyButton
   ...
   MyBtn = NEW MyButton("OK", hForm)
   ...
 END

Come è possibile capire dall'esempio, nella funzione "CreaMyButton()", viene definito un oggetto MyBtn di tipo MyButton (la nostra classe), e nella sua creazione vengono passati due parametri: la stringa "OK" e hForm. Il primo rappresenta l'etichetta da stampare sul pulsante, il secondo il riferimento all'oggetto contenitore (una Form). E' da notare la posizione dei due parametri, in cui nel primo posto viene passata l'etichetta, nel secondo il riferimento al contenitore; nella creazione della classe MyButton, come prima cosa viene creata la classe base Button, a cui verrà passato il riferimento alla Form (il secondo parametro), quindi verrà creata la classe derivata MyButton, a cui verrà passata l'etichetta che abbiamo definito come parametro nel metodo _new() (primo parametro).

Con questa logica è anche possibile definire parametri opzionali (OPTIONAL), magari con valori di default che verranno impostati se non presenti nella creazione dell'oggetto:

Esempio: 

 INHERITS Button
 ...
 PUBLIC SUB _new( OPTIONAL etichetta AS String = "OK" )  'se non passata, l'etichetta sarà impostata a "OK"
   ...
   WITH ME
     .Text = etichetta
   END WITH
   ...
 END


Passare dati ad un Oggetto all'atto della sua creazione

Se si intende passare dati a un Oggetto di una Classe specifica, ciò va fatto all'atto della sua creazione con la parola-chiave "New" passando uno o più argomenti: 

oggetto = New Classe_Specifica(argomento_1, argomento_2, etc...)

Tali dati passati come argomenti, affinché possano essere effettivamente ricevuti ed utilizzati dall'Oggetto, dovranno essere previsti esplicitamente come parametri del Medoto nascosto "_new()" nel codice della sua Classe specifica: 

Public Sub _new(parametro_1 As tipo_di_dato, parametro_2 As tipo_di_dato, etc...)

End

all'interno possono essere assegnati i parametri ad altrettante Proprietà dell'oggetto, o condizionarne il funzionamento (es. definire le dimensioni iniziali di una Form).


_free() - Il Distruttore

Come esiste un Costruttore, esiste un Distruttore, a completamento del filo logico. In Effetti, come anche in altri linguaggi, questo "Distruttore" esiste, e in Gambas è assunto dal metodo "_free()".

Il metodo _free() ha il non semplice compito, almeno per quanto riguarda le operazioni a basso livello, di chiudere e rilasciare le risorse occupate e utilizzate dalla classe. In definitiva è un pulitore.

Il motore di Gambas ha una sua logica interna, che provvede automaticamente questo tipo di pulizia, che avviene normalmente per gli oggetti grafici, come ad esempio le Form e gli oggetti che racchiudono; ma, in alcuni casi, è necessario provvedere manualmente (inteso come codice) a liberare le risorse utilizzate. Questo è il caso, per esempio, di file aperti nella classe, di link a oggetti esterni alla classe, e così via. In questi casi, l'oggetto, non essendo in effetti consapevole degli elementi inseriti, al di fuori degli elementi previsti (esempio precedente, oggetti grafici), non prevede di gestirne la loro eliminazione, oltre al fatto che questa non è dipendente da situazioni o logiche previste nella loro impostazione di base. Per questi motivi, viene d'aiuto il metodo "_free()" che, come per "_new()", viene chiamato sempre e comunque, ma solo quando l'oggetto (o la classe) viene distrutta ed eliminata. Il metodo _free() non prevede parametri, nè li accetta, perchè la sua esecuzione è automatica e non può essere alterata da programma. Al suo interno, però, è possibile eseguire tutte le operazioni e il codice necessario alla corretta chiusura dell'oggetto.

Credo sia inutile fare esempi, dato che comunque il codice non dipenderebbe dall'oggetto, ma sarebbe solo codice esterno ad esso; l'unico esempio è quello della dichiarazione del metodo stesso: 

 PUBLIC SUB _free()
   ...
   'codice libero
   ...  
 END

Il Distruttore è solo un Metodo nascosto che viene eseguito al momento della distruzione dell'Oggetto (come fosse un Evento speciale della Classe a cui appartiene) [nota 3], e che di solito viene usato per liberare la memoria allocata dalla Classe (ma non la memoria della Classe !). Più in particolare il Distruttore non distrugge l'Oggetto (che viene cancellato dal Metodo ".Delete()", risorsa dell'Oggetto medesimo), ma la memoria allocata dai Metodi dell'Oggetto.

Il Metodo nascosto _Free() è utilizzabile per pulire determinate situazioni (es. una connessione), che magari non sono state completate correttamente a causa di un'errore nella classe. Il Metodo nascosto "_free()" è in pratica il distruttore della Classe, cioè viene chiamato un attimo prima che questa venga eliminata dalla memoria, ed è utile per pulire l'Oggetto da eventuali riferimenti ad altre Classi, o per chiudere eventuali aperture di stream.

All'interno di questo Metodo nascosto, bisogna controllare (un "IF" di controllo può bastare sicuramente) se le variabili e le proprietà dello stesso siano ancora valide, ovvero non siano già state Nullate dalla procedura automatica di eliminazione dell'oggetto. Infatti potrebbe esserci una Proprietà della Classe che si sta cancellando, che punta ad un Oggetto esterno che non è più valido. In questo caso, andando ad effettuare dei controlli su questa Proprietà, in realtà si potrebbero trovare in due stadi:
1) la proprietà è ancora valida, ovvero il riferimento punta ad un oggetto ancora valido;

2) l'oggetto non esiste più, per cui il "riferimento " contiene un indirizzo non più valido, e quindi si potrebbe trovare Null oppure qualcosa di indefinito. In quest'ultimo caso è possibile usare i metodi di Object, per controllare in che stato l'oggetto sia.
Per "riferimento " si intende tutto quello che non è intrinseco alla Classe stessa.
Se ad esempio si ha un Oggetto grafico di tipo Button nella Form, che è stata inserita fissa tramite l'editor grafico di Gambas, questa viene eliminata automaticamente da Gambas.
Se si ha una variabile che contiene il riferimento ad un altro Oggetto fuori della Classe, Gambas non lo elimina, perché potrebbe essere un Oggetto valido, a prescindere dalla cancellazione di quella Classe. In tal caso, se questo riferimento è da considerarsi non più utile, nel senso che il programmatore non lo intende valido, allora deve essere eliminato.
Se si ha un array di tipo String, questo viene pulito perché contiene dati di livello base (String fa parte di questo gruppo, anche se è in realtà un Oggetto).
Se si ha un array di tipo Integer, anche questo viene eliminato e pulita automaticamente.
Se però la proprietà contiene un oggetto che è utilizzato esclusivamente all'interno della Classe, e non viene né istanziato, né utilizzato da codice esterno, allora anche questa proprietà viene pulita correttamente.


Facciamo un paio di esempi.

Come primo esempio poniamo il caso di avere due classi: Classe1 e Classe2.
Mettiamo che Classe2 abbia una proprietà di tipo Classe1, e che in qualche Metodo gli venga assegnato un oggetto valido ovviamente dello stesso tipo. Quando si va ad eliminare Classe2, l'oggetto Classe1 è sempre vivo, perché assegnato in maniera dinamica dall'esterno, quindi Gambas non può e non deve eliminarlo, in quanto è valido all'interno del progetto. In questo caso è necessario de-referenziare la proprietà della Classe2, mettendola a NULL, e quindi eliminando il puntamento.
Comunque, Classe1 continua sempre a vivere, e continuerà ad esserlo anche se viene posta a NULL la proprietà di Classe2, perchè non è essa quella che ha creato Classe1, ma ne teneva solo l'indirizzo in memoria.
L'eliminazione di Classe1 deve essere fatta solo da chi l'ha creata !

Nel secondo esempio, poniamo il caso di avere prima l'assegnazione del testo presente in una TextLabel1 alla proprietà .Text di un Button1, e successivamente la cancellazione di TextLabel1.Text.
In questo caso viene assegnato un valore stringa, che è un tipo di dato base, e che in Gambas viene passato come valore, quindi una copia conforme all'originale. Se si cancella TextLabel1.Text, il valore in Button1.Text viene mantenuto, perchè è un clone indipendente. Stessa cosa se si modifica l'uno rispetto all'altro, i due valori sono distinti, dalla copia in poi.
Poniamo il caso che si intenda mantenere un riferimento all'oggetto TextLabel1, per generica utilità all'interno del progetto. Supponiamo quindi sia stata creata una variabile $Txlb, a cui poi si assegni l'oggetto TextLabel1, questa variabile riceverà il puntatore a TextLabel1, ovvero l'indirizzo in memoria dell'oggetto TextLabel1 (non una copia), per cui qualsiasi operazione si fa attraverso $Txlb si rifletterà su TextLabel1. Se, in ipotesi, si decide di eliminare $Txlb, questo non eliminerà però l'oggetto originale, e quindi TextLabel1 continuerà ad esistere. Per tanto, se si intende eliminare TextLabel1, bisognerà per forza utilizzare la Classe che lo contiene, di cui ha la paternità, e che avrà il compito di eliminare i suoi oggetti. Per lo stesso motivo, se elimina il padre, ad esempio una Form, questa eliminerà prima tutti i suoi children, e poi se stessa.
Ritornando alla variabile $Txlb, che supponiamo sia una Proprietà di una Classe specifica. Se si va ad eliminare la detta Classe specifica, bisognerà anche pulire tutti i riferimenti che ha, compresi quelli dei suoi figli. Quindi, essendo $Txlb un riferimento ad un oggetto esterno, bisognerà eliminare l'aggancio che $Txlb ha con questo oggetto, semplicemente mettendolo a Null (riferimento nullo, o void). Questa operazione è necessaria, in quanto Gambas non lo fa in questo caso, perchè non può sapere che uso si sta facendo della classe, ed è per questo motivo che ogni oggetto ha un metodo distruttore: appunto "_free()".
In altri linguaggi il concetto è identico, anche se la sintassi è diversa. In C++ e Java, per esempio, la definizione del costruttore e del distruttore è obbligatoria, anche se non necessariamente codificata. Il costruttore è in pratica il punto d'ingresso della classe, e che si occupa dell'attivazione della stessa e dei suoi elementi. Il distruttore è quello che si occupa di eliminare tutte le tracce in memoria della classe, una volta che non serve più.

Come si è detto in precedenza, vanno fatti dei controlli, ma le operazioni vanno fatte solo se gli oggetti sono validi, e non se sono invalidi. Se v'è un oggetto valido, è possibile pulire la proprietà che lo contiene, relativa all'oggetto che contiene "_free()".
Riguardo al dopo non si deve fare nulla, e non si deve restituire nulla. Il metodo "_free()" non è reversibile, ma permette di fare gli ultimi ritocchi per pulire bene la memoria. A volte la pulizia automatica di Gambas non fa completamente il suo dovere, anche perché molte cose non può, e non deve, toccarle. A questo punto sta al programma controllare lo stato delle cose e agire di conseguenza. La mancata pulizia degli oggetti, fa sì che vengano emessi messaggi di Warning alla chiusura dell'applicazione che, appunto, indicano che ci sono oggetti ancora attivi in memoria. La cosa, ad ogni modo, non è sia bloccante, è esclusivamente una questione di pulizia. Tutto quello che è stato utilizzato dal programma, viene ignorato dal sistema operativo, e reso mediamente disponibile.
Questo però non realmente valido, se vi sono dei processi in background, cui nessuno si occupa di eliminarli fisicamente dalla memoria. Di solito questi processi, se non vengono chiusi e puliti correttamente, restano come "zombie" nel sistema, e solo un "kill -9 " può eliminarli. ...ma per fortuna stiamo parlando di Linux, per cui processi impazziti non sono realmente un problema.


Note

[1] Riportiamo in questa pagina in modo più organico semplicemente diversi interventi e messaggi scritti su quest'argomento dall'utente md9327 del forum Gambas-it.org .

[2] In sostanza va tenuto presente che, se in una Classe è stato posto il Metodo nascosto _new( ):
- - - - all'atto della creazione di tale Classe - per mezzo della parola-chiave New - viene immediatamente invocato il predetto Metodo nascosto _new( );
- - - - è possibile passare mediante il Metodo nascosto _new( ) uno o più parametri alla nuova Classe immediatamente e contestualmente all'atto della sua creazione (effettuata con la parola-chiave New), come nell'esempio che segue:
- - - - se ad esempio nella Classe principale viene creata la Classe secondaria passando a quest'ultima un parametro di tipo Stringa: 

Dim cl As Classe_secondaria
 
cl = New Classe_secondaria("testo qualsiasi")

- - - - nella Classe secondaria il parametro verrà immediatamente recepito, prima di ogni altro metodo in essa eventualmente presente, appunto con il Metodo nascosto _new( ) e gestito di conseguenza come di consueto: 

Public Sub _new(s As String)
 
 Print s
 
End

[3] Facciamo ora un semplice esempio utilizzando due Classi: una Classe principale e una Classe secondaria.
La Classe principale (chiamata "FMain") avrà al suo interno il seguente codice: 

Private cl1 As Class1

' Questo Metodo nascosto della Classe principale viene sollevato all'atto della creazione della Classe principale medesima:
Public Sub _new()
 
 Print "Classe Principale in creazione"
 
' In questo caso all'atto della creazione della Classe principale si provvede anche creare una Classe "secondaria" (chiamata "Class1") inviandole pure alcuni argomenti:
 cl1 = New Class1("Testo qualsiasi", 4444)
 
End


Public Sub Button1_Click()

' Si provvede a distruggere la Classe "secondaria" assegnando "Null" alla variabile che punta al suo Oggetto. (è opportuno ricordare che una Classe secondaria può essere distrutta soltanto dalla Classe che l'ha generata).
 cl1 = Null
 
End

Mentre il codice nella Classe "secondaria" sarà il seguente: 

' Questo Metodo nascosto della Classe "secondaria" viene sollevato all'atto della creazione della Classe "secondaria" medesima, e riceve gli argomenti passati con l'istruzione della creazione della Classe "secondaria" mediante la parola-chiave "New":
Public Sub _new(s As String, i As Integer)
 
 Print "Classe secondaria in creazione"
 
 Print s, i
 
End

' Questo Metodo nascosto della Classe "secondaria" viene sollevato all'atto della "distruzione" della Classe "secondaria" medesima:
Public Sub _free()
 
 Print "Classe secondaria in distruzione"
 
End

Insomma, i Metodi nascosti "_new()" e "_free()" non creano e non distruggono direttamente alcunché: essi, comportandosi come degli Eventi, sono sollevati rispettivamente all'atto della creazione e all'atto della distruzione della Classe di riferimento.

Estratto da "https://www.gambas-it.org/wiki/index.php?title=Metodi_nascosti:_New()_e_Free()&oldid=42122"