Newsgroup: it.comp.lang.c
Titolo: Dimensione di una struttura

Ciao a tutti.
Mi trovo davanti ad un problema al quale non trovo risposta. Riporto
parte del codice...
Ho la seguente struttura
typedef struct
{
  unsigned int codice; /*Chiave esterna*/
  int peso; /*Peso in grammi*/
  char fuso; /*Primi 4 bit=numero fuso (1 a 24)
                     5 bit=True Macchina 2
                     5 bit=False Macchina 1 */
}VALORI;
e una funzione che mi chiede dei valori
VALORI *askval(int from,int to)
{
    int peso;
    VALORI *p,*v;
   /* extern void intinput(int *num,int maxval); ancora da testare */
    /*Temporaneo controllo della lunghezza*/
    printf("\nValori e' %d\n", sizeof(VALORI));
    v=(VALORI *)malloc((to-from+1)*sizeof(VALORI));
    if(v==NULL)
    {
        printf("Errore nell'allocazione di memoria....");
        printf("Ci sono ancora gli incentivi sulla rottamazione");
       exit(0);
    }
    p=v;
    for(;from<=to;from++,p++)
    {
       printf("\nInserire il peso della rocca n.%d :",from & 037);
       scanf("%d",&peso); /*Sopperisco tempor. ad intinput*/
       /*intinput(&peso,MAX_PESO); pazienza*/
       p->peso=peso;
       p->fuso=from;
       p->codice=6666; /*Valore temporaneo*/
   }
   return v;
}
Vengo al dunque....
La struttura e' composta da due interi ed un char, cioe' 4+4+1
bytes...(Il tipo int misura 4 bytes sulla mia macchina)
Invece no: per un motivo che non so occupa 12!!!! bytes, cioe'
3 bytes in piu' di quello che ho calcolato. DIfatti la prima printf
della funzione mi conferma appunto 12.
Perche'? 
PS Ho sentito parlare di allineamento naturale delle strutture, ma
c'entra qualcosa??
Igor ROssetti

 c'entra qualcosa??
Immagino proprio di si!
EMG

Igor ROssetti
ti posto qui un pezzo della pagina del MSDN che parla di queste cose,
se ti interessa anche il resto scrivimi, te lo mando via E-mail.
"...The following guidelines ensure proper alignment for processors
targeted by Win32:
Type            	Alignment 
char           	Align on byte boundaries 
short (16-bit)  	Align on even byte boundaries 
int (32-bit)    	Align on 32-bit boundaries 
long (32-bit)   	Align on 32-bit boundaries 
float           	Align on 32-bit boundaries 
double          	Align on 64-bit boundaries 
structures      	Largest alignment requirement of any member 
unions          	Alignment requirement of the first member ..."
ciao,
knip.

unions          	Alignment requirement of the first member ..."
Non e' che per caso queste due le hai scambiate ?
Andrea
--
Andrea Griffini, Programmer
http://www.netservers.com/~agriff

c'entra qualcosa??
Si... la dimensione di una struttura e' garantito che non sara'
mai inferiore alla somma delle dimensioni dei membri; ma non e'
detto che debba coincidere con questa somma.
Il problema e' che certi datatype in certe architetture possono
presentare problemi se l'indirizzo del dato non e' multiplo
di un determinato valore.
Su x86 i problemi sono semplicemente di performance (il processore
perde piu' tempo a leggere dati non allineati) mentre in altri
casi l'accesso al dato e' impossibile (ad esempio esistono
processori che non possono accedere ad un intero a 32 bit a meno
che il primo byte del valore si trovi ad un indirizzo multiplo
di 4).
Questa e' una delle tante ragioni per cui scrivere una struttura
su disco per scambiare dati (o per salvarli) non e' una tecnica
portabile su diverse piattaforme o diversi compilatori.
Su *alcuni* compilatori e' possibile chiedere che i dati non
vengano allineati e le strutture siano cioe' create il piu'
"compatte" possibile... si tratta pero' di qualcosa che
dipende fortemente dall'ambiente (l'HW deve essere in grado
di accedere a dati con qualunque allineamento) e, anche in uno
stesso ambiente, non e' detto che tutti i compilatori
permettano la cosa.
HTH


Non e' che per caso queste due le hai scambiate ?
no, ho fatto cut and paste dall'articolo....
ma hai ragione la def delle union e' cannata, e' evidente che nella
union disegnata sotto la allocazione e' di 8 e non di 4 come
richiederebbe il primo elemento.
union VariNumeri
{
	int	SonoUnIntero;
    	long	SonoUnLongo;
    	double	SonoUnDublo;
};
|_ _ _ _|		int
|_ _ _ _|		int
|_ _ _ _ _ _ _ _|	double
0         4          8
per le structures invece mi sembra corretta la somma dei Largest
Alignement dei membri...
ciao.