Gestione delle Strutture esterne

Nell'uso delle funzioni esterne mediante la risorsa "Extern" è frequente imbattersi nell'uso e nella gestione di Strutture, dichiarate e definite nei file d'intestazione delle librerie esterne utilizzate.
Pertanto un'accurata comprensione e un'attenta gestione di tali Strutture esterne nel codice Gambas è assolutamente determinante per il corretto funzionamento del codice medesimo. ^{[nota 1] [nota 2]}

Nel codice Gambas si dovrà innanzitutto ricostruire la Struttura esterna.
Tale ricostruzione in Gambas deve essere precisa, avendo estrema cura per la definizione del tipo di dato di ciascun membro della Struttura esterna.
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.
Va aggiunto a ciò che ugualmente estrema attenzione bisognerà avere per le regole dell'allineamento dei membri e dei campi di una Struttura. Tale "allineamento" presente nella Struttura, ricostruita in Gambas, dovrà perfettamente coincidere con quello presente nella Struttura esterna.

A titolo esemplificativo va detto che:
- 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 è senza segno);
- 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

Paragrafo in costruzione !

Membro del tipo di un'altra Struttura

Paragrafo in costruzione !

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

Paragrafo in costruzione !

Membro del tipo Puntatore a un'altra Struttura

Paragrafo in costruzione !

Gestione delle "Union"

Una "Unione" è un'area di memoria allocata che può contenere - in momenti diversi - dati di diversa dimensione e tipo, comunque condividendo sempre il medesimo spazio di memoria. In tal senso lo spazio riservato per una "Union" corrisponde soltanto a quello necessario per il suo membro più grande. Pertanto la Union contiene il dato di un solo membro per volta.
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 ogni qual volta deve essere valorizzato un suo membro, il dato di uno solo 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.
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".
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 membro (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).

Riassunto esemplificativo

Di seguito mostriamo una Struttura principale in linguaggio C che contiene in sé membri che riassumono i casi sopra esposti.

#include <stdio.h>


struct Secondaria {
  char a;
  int i;
  char b[4];
  char c;
};

struct PRINCIPALE {
  char a;
  int i;
  char cc[4];
  char *c;
  char *ccc[4];
  struct Secondaria s;
  struct Secondaria *sp;
  struct Secondaria sa[4];
  struct Secondaria *spa[4];
  struct INNESTATA {
     char ina;
     int ini;
     char inb[4];
     char inc;
  } inn;
  union UNIONE {
     char unc; 
     short int uns;
     long int unl;
  } un;
};


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

Paragrafo in costruzione !

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