Newsgroup: it.comp.lang.c
Titolo: Allineamento dei field di una struct

Salve a tutti, 
leggendo la specifica ANSI non sono riuscito a trovare una risposta 
(sicuramente ci sara`) a questo mio semplice ma peculiare quesito:
nell'allocazione di una struct i cui campi siano *unicamente* dei 
vettori di caratteri (es. struct MiaStruct{char a[10], b[12], c[18], d
[2]};) mi e` concesso assumere che tutti i campi siano allocati in modo 
contiguo anche se le dimensioni dei buffer non sono multiple della 
parola di memoria della macchina su cui gira il programma? 
Posso cioe` assumere che b[0] sia sempre allocato nella cella 
immediatamente successiva a a[9], c[0] nella cella immediatamente 
successiva a b[11] e d[0] nella cella immediatamente successiva a c[17]?
Per certo questo non avviene se vengono intercalati vettori di char e 
int ad esempio...ma in questo caso non ne sono sicuro, anche perche` 
casualmente il compilatore me le alloca sempre in modo contiguo...
Grazie tante.
Inviato da 
www.mynewsgate.net

 
Molti compilatori effettivamente impacchettano i char ma, se non c'e` la 
direttiva packed (o equivalente) e vi e` una ottimizzazione spinta, 
potrebbero generare delle strutture in cui i char non sono contigui per 
velocizzare l'accesso.


 ha scritto:

Ciao Giovanni,
sono certo che il tuo consiglio e` piu` che valido...ma scusa, che 
vantaggi pensi si potrebbero ricavare in termini di velocita` da una 
allocazione non packed di una struct del genere?
La granularita` di accesso ad un array di caratteri e` pur sempre il 
carattere [== 1 byte] dunque la lettura di una qualunque delle celle di 
un vettore di caratteri provocherebbe sempre il caricamento di una e una 
sola parola di memoria (dalla quale ne verrebbe estratto il byte di 
interesse). Anche i meccanismi di cashing non penso che ne trarrebbero 
gran vantaggio giacche` basano la loro esistenza sul principio della 
localita` (vicinanza tra parole di memoria) che in ogni caso direi 
proprio che e` garantita!
Inviato da 
www.mynewsgate.net

 carattere [== 1 byte]
Sì ma, nella maggior parte dei casi, di un array di char (NON "di
caratteri"! Un char non è necessariamente un carattere) si usa solo il
puntatore al primo elemento: per passarlo a una funzione, per ritornarlo da
una funzione, per assegnarlo a un altro puntatore, ecc.
Solo saltuariamente si va ad accedere ai singoli char dell'array e, nella
maggior parte dei casi, questo avviene all'interno di funzioni di libreria
che potrebbero essere scritte in assembler, o comunque con ottimizzazioni
specifiche per l'ambiente d'esecuzione.
In ogni caso, paddare un array di char dentro una struttura alla granularità
d'indirizzamento naturale è l'unico modo che il compilatore ha per allineare
l'indirizzamento del campo successivo, che non necessariamente è un altro
array di char.
In ogni caso, che senso ha la tua domanda? Se hai bisogno che sia garantito
questo comportamento, invece di dichiarare: "{char a[10], b[12], c[18], d
[2]}", puoi dichiarare: "{char x [42]}". Oppure, se il tuo compilatore ne
dispone, usi il pragma o l'opzione di compilazione per impaccare i campi
delle strutture, di cui quasi tutti i compilatori dispongono.
--
Cingar
--------------------------------
Inviato via 
http://arianna.libero.it/usenet/

 
Il senso della mia domanda e` piuttosto semplice: vorrei avere a disposizione 
delle strutture dati che concettualmente siano dei buffer di caratteri (e 
quindi all'occorrenza castarle a char* per poterle passare a delle API di un 
processo remoto che si aspetta le informazioni in formato packed) ma vorrei 
avere allo stesso tempo l'opportunita` (dalla mia applicazione) di accedere 
ai campi con l'uso di dot notation anziche` con l'ausilio dell'operatore 
parentesi quadra....tutto qua`! Solo ragioni di eleganza e buona leggibilita` 
del codice. 
Grazie comunque
Inviato da 
www.mynewsgate.net

 Grazie comunque
"Comunque" una cippa. Più di una persona ti ha già risposto più che
sufficientemente sia sugli aspetti teorici che su quelli pratici. Se non sei
soddisfatto, comprati una bambolina di quelle a cui schiacci il pancino e
dicono "Bravo! Hai ragione!".
Addio.


 
Non ti rispondo a tono, solo per essere piu` educato di te.
Inviato da 
www.mynewsgate.net

 accertarmi riguardo alla portabilita` di cio` che avevo in mente.
Se vuoi la portabilita' scordati che gli array di caratteri possano
avere avere una qualche caratteristica diversa da quelle esplicitamente
specificate nello standard per gli array.
Il fatto che sul tuo compilatore le cose funzionino ad un certo modo
non va preso come oro colato.
Esempi su quest'ultimo punto a richiesta.
C:\>iao Angelo
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 
Inviato da 
www.mynewsgate.net

 per il termine "word" che dipende dalla macchina.
Visto che l'inglese lo sai, non credo debba tradurti la nota 2.
Decisamente non fai una bella figura...


 
Mi sono sbagliato, chiedo scusa. Ignoravo l'esistenza di certe 
architetture.
Inviato da 
www.mynewsgate.net

 linguaggio.
Hai ragione, scusa. Ritiro "una cippa" e metto il più castigato "un cavolo".
