Visualizza wikitesto di Gestione delle Strutture esterne

Nell'uso delle funzioni esterne mediante la risorsa "[[Extern: richiamare funzioni esterne a Gambas|Extern]]" è frequente imbattersi nell'uso e nella gestione di Strutture, dichiarate e definite nei file d'intestazione delle librerie esterne utilizzate.
<BR>Pertanto un'accurata comprensione e un'attenta gestione di tali Strutture esterne nel codice Gambas è assolutamente determinante per il corretto funzionamento del codice medesimo. <SUP>&#091;[[#Note|nota 1]]&#093;</sup> <SUP>&#091;[[#Note|nota 2]]&#093;</sup>

Nel codice Gambas si dovrà innanzitutto ricostruire la Struttura esterna.
<BR>Tale ricostruzione in Gambas deve essere precisa, avendo <SPAN Style="text-decoration:underline">estrema cura</span> per la definizione del [http://gambaswiki.org/wiki/doc/extern tipo di dato] di ciascun membro della Struttura esterna.
<BR>Ciò richiede una conoscenza almeno sufficiente del linguaggio C, poiché nella ricostruzione in Gambas della Struttura esterna, scritta in C, bisognerà rispettare la totale dimensione (ossia la quantità di byte di memoria occupata da quest'ultima), che potrà avvenire soltanto attraverso il rigido rispetto della quantità di byte occupati del tipo di dato dichiarato per ciascun membro componente della Struttura esterna.
<BR>Va aggiunto a ciò che ugualmente estrema attenzione bisognerà avere per le regole dell'<SPAN Style="text-decoration:underline">allineamento dei membri e dei campi</span> di una Struttura. Tale "allineamento" presente nella Struttura, ricostruita in Gambas, <SPAN Style="text-decoration:underline">dovrà perfettamente coincidere</span> con quello presente nella Struttura esterna. 

A titolo esemplificativo va detto che:
<BR> - in un Struttura esterna un membro di tipo "char" con segno (capace dunque di rappresentare un valore compreso tra -127 e +127, occupando così 1 byte di memoria) andrà comunque dichiarato nella ricostruzione della Struttura in Gambas come un membro di tipo "Byte" (anche se questo tipo di dato in Gambas è <SPAN Style="text-decoration:underline">senza</span> segno);
<BR> - in C non esiste il tipo di dati "String"; e pertanto un membro di una Struttura esterna, dichiarato come "char *" (che occupa dunque la quantità di memoria occupata da una variabile di tipo "Puntatore"), va dichiarato nella Struttura ricostruita in Gambas come un "Puntatore".


==Struttura esterna che contiene membri di tipo array==

<FONT Color=red size=4><B>Paragrafo in costruzione !</b></font>


==Membro del tipo di un'altra Struttura==

<FONT Color=red size=4><B>Paragrafo in costruzione !</b></font>


==Membro del tipo di una Struttura innestata (annidata) all'interno della Struttura principale==

<FONT Color=red size=4><B>Paragrafo in costruzione !</b></font>


==Membro del tipo Puntatore a un'altra Struttura==

<FONT Color=red size=4><B>Paragrafo in costruzione !</b></font>


==Gestione delle "Union"==
Una "Unione" è un'area di memoria allocata che può contenere - in momenti diversi - dati di diversa dimensione e tipo, comunque <SPAN Style="text-decoration:underline">condividendo sempre il medesimo spazio di memoria</span>. In tal senso <SPAN Style="text-decoration:underline">lo spazio riservato per una "Union" corrisponde soltanto a quello necessario per il suo membro più grande</span>. Pertanto la ''Union'' contiene il dato di <SPAN Style="text-decoration:underline">un solo membro per volta</span>.
<BR>Così se abbiamo questa "Unione":
 union UNIONE {
   char c; 
   short int s;
   long int l;
 }
la quantità di memoria occupata da tale esempio di ''Union'' è uguale a 8, ossia alla quantità di memoria occupata dal membro più grande (in tal caso quello di tipo "long int"). Inoltre, dovendosi potrà contenere <SPAN Style="text-decoration:underline">ogni qual volta</span> deve essere valorizzato un suo membro, il dato di <SPAN Style="text-decoration:underline">uno solo</span> dei suoi tre membri.

In Gambas una "Union" va ricreata attraverso la usuale Classe "Struct", avendo l'accortezza di occupare una quantità di memoria pari alla totale quantità di memoria allocata per la "Union" della libreria esterna scritta in C.
<BR>Di ciò bisogna avere cura anche qualora si utilizzi, poi, nel codice Gambas esclusivamente un membro della "Union" la cui complessiva dimensione di memoria occupata sia inferiore alla quantità di memoria che deve essere riservata per la "Union". In tal caso si aggiungerà un membro fittizio, ad esempio un array di tipo Byte, con un numero di elementi pari al numero necessario per coprire l'intera quantità di memoria da riservare per la "Union".
<BR>Se ad esempio la "Union" nella libreria esterna, formata da un membro di tipo di una "Struttura" e da un array di tipo Byte, laddove il membro di tipo "Struttura" occupa una quantità di memoria inferiore alla complessiva quantità di memoria occupata dall'array, ovviamente la quantità di memoria che il sistema riserverà per la "Union" è pari alla quantità di memoria occupata dal predetto array. In questo caso, se interessa in Gambas utilizzare solamente la "Struttura" quale <SPAN Style="text-decoration:underline">membro</span> (in questo esempio) della "Union", porremo nella "Struttura" (che in Gambas deve ricreare la "Union" esterna) anche l'array di tipo Byte (che casualmente è già un membro componente della "Union" esterna) con un numero di elementi pari alla differenza fra la quantità di byte di memoria, occupata dalla "Union" esterna scritta in C, e la quantità di memoria che sarà occupata dal membro di tipo della "Struttura" (anch'esso, come sappiamo, costituente la "Union" esterna).


==Allineamento dei membri nell'area di memoria allocata di una Struttura==
Quando la quantità di byte, occupati dal tipo di dati di un membro, successivo al primo, di una ''Struttura'', è superiore alla quantità occupata dal tipo di dati del membro precedente, esso è posto al numero d'indice (''offset'' ) uguale alla quantità di byte occupati dal tipo di dati di appartenenza. Se il numero d'indice è già occupato, allora la collocazione del membro scorre al numero d'indice uguale al multiplo della predetta quantità di byte, occupati da suo tipo di dati, immediatamente successivo purché libero.

Se invece la quantità occupata dal tipo di dati di un membro è inferiore o uguale a quella occupata dal mebro precedente, esso è posto al numero d'indice immediatamente libero dopo il membro che lo precede.

Così in C, se una ''Struttura'' è composta ad esempio da un membro di tipo "char" e da un membro di tipo "int", la quantità di memoria, occupata dal titpo di dati ("int" = 4 byte) del secondo membro, è superiore alla quantità occupata dal tipo di dati del primo ("char" = 1 byte), l'allineamento dei due membri all'interno dell'area di memoria riservata della ''Struttura'' sarà il seguente:
 struct STRUTTURA {
    char c; <FONT Color=blue>/* Posizionato al numero d'indice 0; occupa un solo byte */</font>
    int i;  <FONT Color=blue>/* Poiché il 2° membro occupa 4 byte, allora esso è collocato al numero d'indice 4, atteso che è libero */</font>
 };
Pertanto, la quantità complessiva di memoria occupata dai membri da questa ''Struttura'' è pari a 8 byte.

In quest'altra ''Struttura'' invece avremo:
 struct STRUTTURA {
    char c; <FONT Color=blue>/* Posizionato al numero d'indice 0; occupa un solo byte */</font>
    int i;  <FONT Color=blue>/* Poiché il 2° membro occupa 4 byte (numero superiore a quello del primo membro), allora esso è collocato al numero d'indice 4, atteso che è libero */</font>
    short int s;  <FONT Color=blue>/* Poiché la quantità occupata da questo occupa è inferiore a quella del mebro precedente, esso è posto al numero d'indice immediatamente libero dopo il membro precedente: ossia 8 */</font>
    int n;  <FONT Color=blue>/* Poiché questo membro occupa 4 byte (numero superiore a quello del membro immediatamente precedente), allora esso dovrebbe essereè collocato al numero d'indice 4. Essendo però tale numero d'indice già occupato, lo si porrà al primo numero d'indice multiplo di 4 libero: in questo caso 12 */</font>
    long int l;   <FONT Color=blue>/* Poiché questo membro occupa 8 byte, ossia una quantità superiore a quella occupata dal membro precedente, esso dovrebbe essere collocato al numero d'indice 8, ma essendo già occupato, si porrà al primo numero d'indice multiplo di 8 libero: in uesto caso 16 */</font>
 };
Pertanto, la quantità complessiva di memoria occupata dai membri da questa ''Struttura'' è pari a 24 byte.


==Riassunto esemplificativo==
Di seguito mostriamo una ''Struttura'' principale in linguaggio C che contiene in sé membri che riassumono i casi sopra esposti.
<BR>Nei commenti al codice sono specificati i numeri d'indice ''offset'' di inizio collocazione in memoria di ciascun membro della ''Struttura'' e la quantità di byte di memoria da ognuno occupata, tenendo anche in debito conto degli allineamenti dovuti.
 #include <stdio.h>
 
 
 struct Secondaria {   <FONT Color=gray>' ''(Questa "Struttura" occupa 16 byte di memoria, considerando anche il necessario allineamento)''</font>
   char a;
   int i;
   char b[4];
   char c;
 };
 
 struct '''PRINCIPALE''' {
   char a;   <FONT Color=gray>' ''Inizio indice 0; 1 byte di memoria occupato''</font>
             <FONT Color=gray>' ''Essendo il prossimo membro un Intero, che occupa 4 byte, è richiesto un allineamento, affinché esso inizi a un indice pari o multiplo della quantità di memoria occupata dal tipo di dati "int"''</font>
   int i;    <FONT Color=gray>' ''Inizio indice 4; 4 byte di memoria occupati''</font>
 
   char cc[4];   <FONT Color=gray>' ''Vettore di tipo "char" con 4 elementi; inizio indice 12; 3x1 byte di memoria occupati''</font>
   char *c;      <FONT Color=gray>' ''Puntatore a un tipo "char"; inizio indice 16; 8 byte di memoria occupati''</font>
   char *ccc[4]; <FONT Color=gray>' ''Vettore di Puntatori a un tipo "char" con 4 elementi; inizio indice 24; 4x8 byte di memoria occupati''</font>
 
   struct Secondaria s;   <FONT Color=gray>' ''Membro del tipo "struct Secondaria"; inizio indice 56; 16 byte di memoria occupati''</font>
   struct Secondaria *sp; <FONT Color=gray>' ''Puntatore a un tipo "struct Secondaria"; inizio indice 72; 8 byte di memoria occupati''</font>
   struct Secondaria sa[4]; <FONT Color=gray>' ''Vettore di tipo "struct Secondaria" con 4 elementi; inizio indice 80; 16x4 byte di memoria occupati''</font>
   struct Secondaria *spa[4]; <FONT Color=gray>' ''Vettore di tipo Puntatore a un tipo "struct Secondaria"; inizio indice 144; 8x4 byte di memoria occupati''</font>
 
   struct INNESTATA {
      char ina;
      int ini;
      char inb[4];
      char inc;
   } inn;   <FONT Color=gray>' ''Membro con Struttura innestata del tipo "struct INNESTATA"; inizio indice 176; 16 byte di memoria occupati''</font>
 
   union UNIONE {
      char unc; 
      short int uns;
      long int unl;
   } un;    <FONT Color=gray>' ''Membro con una "Union" innestata ; inizio indice 192; 8 byte di memoria occupati''</font>
 };
 
 
 int main() {
 
   printf("%ld\n", sizeof(struct PRINCIPALE));
 
   return (0);
 
 }
La quantità di memoria comlessiva, occupata dalla descritta ''Struttura'' principale, è pari a 200 byte.

==Gestione dei Campi bit di una Struttura==

<FONT Color=red size=4><B>Paragrafo in costruzione !</b></font>



=Note=
[1] Si veda anche questa pagina: [[Gestire con un Puntatore le Strutture esterne]]

[2] Per un approccio diverso alle Strutture esterne, si veda la seguente pagina: [[Gestire con sicurezza le Strutture esterne]]