Differenze tra le versioni di "Gestire con un Puntatore le Strutture esterne"

Versione delle 09:25, 15 mag 2015

Come descritto anche in questa pagina, dedicata alla gestione in modo sicuro delle Strutture esterne, la lettura e la scrittura effettuate su Strutture esterne di una certa complessità è sempre molto difficile. Tanto è che, nella pagina segnalata nel collegamento, si è proposto nei casi più difficili di creare un'apposita libreria dinamica .so esterna scritta in C, nella quale gestire con le risorse del linguaggio C i membri di tali Strutture molto complesse sia in lettura che in scrittura.

La difficoltà della gestione delle Strutture molto complesse, appartenenti a librerie condivise .so esterne, consiste nel fatto che, tentando di riprodurre nel progetto Gambas tali Strutture, il linguaggio non riesce sempre a gestire la coerenza dei necessari allineamenti tra alcuni particolari membri costituenti la Struttura medesima.

Ad ogni modo alcune Strutture complesse possono essere affrontate tentandone la lettura e la scrittura attraverso un Puntatore, all'interno dell'area da esso puntata si scorrerà con i Memory Stream (per la lettura e/o scrittura), oppure semplicemente sommando o sottrando valori alla variabile Puntatore e dereferenziando con le apposite funzioni di dereferenziazione di un Puntatore previste da Gambas (solo per la lettura).

L'ostacolo maggiore è rappresentato dagli eventuali necessari allineamenti fra i membri, dei quali si dovrà tenere rigidamente conto durante la lettura e la scrittura nello spostamento lungo l'area puntata dal Puntatore.

In particolare, sorvolando sull'ovvia circostanza che i valori del primo membro della Struttura esterna sono leggibili e scrivibili a cominciare dal primo byte dell'area puntata dal Puntatore, v'è da precisare che per i valori appartenenti ai membri successivi al primo membro, il primo byte del valore di ogni membro (successivo al primo in assoluto della Struttura) si trova al numero di indice uguale al valore che rappresenta la dimensione (quantità di byte occupati) del tipo di variabile contenente il valore medesimo, oppure uguale al multiplo più prossimo al valore della dimensione predetta.

Cerchiamo di spiegare meglio qquanto detto con un esempio.
Poniamo il caso che la Struttura presente nella libreria condivisa dinamica esterna sia così composta:

struct STRUTTURA
  char c;
  int i;
  char * p;
  short s;
};

Laddove sostanzialmente abbiamo:
il primo membro di tipo char occupa 1 byte di memoria (come in Gambas il tipo Byte);
il secondo membro di tipo int occupa 4 byte di memoria (come in Gambas il tipo Integer);
il terzo membro di tipo char * (Puntatore) occupa 8 byte di memoria (come in Gambas il tipo Pointer);
il terzo membro di tipo short occupa 2 byte di memoria (come in Gambas il tipo Short).

Tali membri sono dislocati all'interno dell'area di memoria occupata dalla loro Struttura secondi il seguente ragionamento e calcolo:

• il valore contenuto dal primo membro, ovviamente, ha inizio nell'area di memoria dal byte di indice 0 (il primo membro coincide sempre con l'indice zero).

Il primo membro occupa, come abbiamo visto solo un byte di memoria nell'area riservata, pertanto il prossimo byte da verificare è quello di indice 1.

• Il secondo membro, però, essendo un Intero (int) ha una dimensione di 4 byte (occupa, cioè, 4 byte di memoria per rappresentare il valore assegnatogli). Pertanto, si dovrà verificare se il numero dell'indice da verificare (abbiamo visto che ora è uguale a 1) coincide con il valore della dimensione del tipo int, oppure con un suo multiplo (8, 12, 16, 20, etc). Notiamo che 1 (l'indice attuale) non coincide con il 4 (dimensione di memoria occupata dal tipo int) né con un suo multiplo. Pertanto, sposteremo in avanti l'indice di un altro byte per la verifica. L'indice 1 resterà con valore zero ed entrando così a far parte dell'allineamento.

Ora verifichiamo il nuovo indice: 2, che come il precedente non corrisponde al numero 4 (ricordiamo che v'è da piazzare un Intero !) né ad un multiplo di 4. Quindi spostiamo ancora in avanti il puntatore interno dell'indice (offset), come fatto appena prima, e lasceremo a zero anche il terzo byte (ossia quello di indice 2 !), entrando così anch'esso a far parte dell'allineamento.

Ora verifichiamo il nuovo indice: 3, che come il precedente non corrisponde al numero 4 (ricordiamo che v'è da piazzare un Intero !) né ad un multiplo di 4. Quindi spostiamo ancora in avanti il puntatore interno dell'indice, e lasceremo a zero anche il quarto byte (ossia quello di indice 3), entrando così anch'esso a far parte dell'allineamento.

Ora verifichiamo il nuovo indice: 4. Questo numero corrisponde esattamente con il valore della dimensione di un Intero (int). Quindi il primo valore assegnato a tale Intero sarà posto al byte di indice 4 (dunque al 5° byte), e

Pagina in costruzione