Newsgroup: it.comp.lang.c
Titolo: proprietà di allineamento

scusate: la domanda è da prime armi...
mi potete spiegare in parole molto semplici cosa significa "alignment
properties"
e in generale questo punto delle FAQ di comp.lang.c
2.13: Why does sizeof report a larger size than I expect for a
structure type, as if there were padding at the end?
A: Structures may have this padding (as well as internal padding),
if necessary, to ensure that alignment properties will be
preserved when an array of contiguous structures is allocated.
Even when the structure is not part of an array, the end padding
remains, so that sizeof can always return a consistent size.

Esattamente quello che sta scritto :-)
Tu immagina che i Pentium lavorino a 32bits alla volta e che leggano
"meglio" la memoria quando l'indirizzo di partenza č un multiplo di 4 bytes
immagia di avere questo:
struct A {
    int a; // sizeof(a) = 4
    char b; // sizeof(b) = 1
    int c; // sizeof(c) = 4
    char d; // sizeof(d) = 1
}
Ora, la struttura viene allocata su un multiplo di 4 bytes. Quindi a e b
sono allocati su un multiplo di 4 bytes. Perň chiaramente di base c non
sarebbe su un multiplo di 4 bytes (se conti, prima di lui ci sono 5 bytes).
Qui il compilatore quindi inserisce uno "spazio", e fa si che dopo il char b
ci siano 3 bytes "vuoti". Questi "gonfiano" la struttura. Quindi noi abbiamo
che la struttura invece di essere lunga 10 bytes č lunga per ora 13 bytes
(10 bytes + 3 bytes "vuoti"). Ora perň pensa di allocare consecutivamente
due strutture A, facendo cosě:
struct A pippo[2];
Se pippo[0] č lungo 13 bytes, allora se pippo[1] seguisse immediatamente
pippo[0] allora pippo[1] non sarebbe allineato ai 4 bytes. Per questo motivo
il compilatore "padda" di ulteriori 3 bytes la struttura A, aggiungendo
ulteriori 3 bytes "vuoti" dopo il char d. Quindi la struct A ha sizeof (su
un Pentium) di 16 bytes.
(normalmente tu puoi dare dei comandi al compilatore per controllare il
padding delle strutture, e puoi anche usare delle direttive #pragma per
controllare a livello di singola struttura).
--- bye

 Esattamente quello che sta scritto :-)
si, salvo che ora comincio a capire e prima no...
(grazie quindi)
però vorrei anche capire in generale il concetto di allineamento
Tu parli di moduli; scusa quindi la domanda, la lettura come avviene? perchè
è più efficente se l'indirizzo di partenza è modulare? questi moduli
dipendono dal tipo di dato o dal tipo di computer?

 dipendono dal tipo di dato o dal tipo di computer?
Dunque (da quello che ne so). Dipendono dal tipo di computer e
dall'architettura del bus processore-memoria. La memoria (RAM) viene letta a
"blocchi". (che poi sono questi moduli). Non so esattamente perchè se sono
allineati va più veloce (forse è per come è strutturata fisicamente la
memoria), ma è così :-) Chiaramente se tu programmassi per un 286 avresti
allineamenti a 16 bits.
Calcola che il Visual C++ ha come allineamento standard 8 bytes (ma in
realtà c'è un trucco: te lo quoto perchè non ho voglia di tradurlo:
Specifies the value, in bytes, to be used for packing. The default value for
n is 8. Valid values are 1, 2, 4, 8, and 16. The alignment of a member will
be on a boundary that is either a multiple of n or a multiple of the size of
the member, whichever is smaller. Quindi in pratica due int di seguito
occupano 8 bytes, ma un int e un double (sizeof(double) = 8) occupano 16
bytes, e un int, un double e un int occupano 24 bytes, mentre due int e un
double ne occupano ancora 16)
--- bye

sempre io;
- - -
inoltre c'è un'altra cosa che mi sfugge
questi bytes di allineamento sono solo "saltati" e potrebbero quindi essere
utilizzati per memorizzare altri dati o sono fisicamente bloccati alla
struttura che li "avvolge"?
questo me lo chiedo perchè non capisco il senso di dichiarare un char se poi
il compilatore sembra trattarlo come un int...
Inoltre cosa succede in una struttura che contiene, poniamo, 4 membri char e
basta?
(spero di non aver scritto fesserie, sono veramente un dilettante, anche se
appassionato)

 basta?
C'č un trucco (che ti ho scritto nell'altro post). La posizione di una
variabile č o un multiplo del "modulo" o un multiplo della lunghezza della
variabile (si prende il minore dei due). Quindi (per farti un esempio) (con
modulo 4)
short + char + char = 4 bytes (il char puň essere posizionato ovunque,
perchč ha lunghezza 1), e
char + char + short = 4 bytes ma
char + short + char = 8 bytes (lo short deve avere allineamento 2: quindi il
primo char viene paddato di un byte, poi lo short, poi il byte e siamo a 5,
ma a questo punto devi paddare la struct per renderla multipla di 4, quindi
8 bytes)
--- bye

 ha scritto nel messaggio
news:Vo7gc.91630$rM4.3...@news4.tin.it...
grazie mi hai veramente tirato fuori dalla nebbia fitta!

 richieda).
Non vengono posti a zero, bensi` il loro contenuto e` indefinito.