Perché la dimensione della struttura 5 compresso invece di 4 byte qui?

Question

vedi esempio in linea: Ideone example

struct { 
    union { 
    struct { 
     uint32_t messageID : 26; 
     uint8_t priority : 3; 
    } __attribute__ ((packed)); 
    uint32_t rawID : 29; 
    } __attribute__ ((packed)); 
    uint8_t canFlags : 3; 
} __attribute__ ((packed)) idSpecial; 

Perché il rapporto compilatore la dimensione della struttura di 5 byte invece di 4 qui? Dovrebbe contenere 32 bit.

Answer 1

A causa dell'allineamento della memoria: il compilatore non verrà avviato canFlags nel medio di un byte, verrà avviato all'inizio del byte successivo (probabilmente *). Quindi hai quattro byte per l'unione iniziale e un byte per canFlags.

Se, per esempio, si è spostato canFlags nell'unione, sarebbe (forse *) hanno formato 4:

typedef struct structTag { 
    union { 
    struct { 
     uint32_t messageID : 26; /* 26bit message id, 67108864 ids */ 
     uint8_t priority : 3; /* priority: MUST BE 0 */ 
    } __attribute__ ((packed)); 
    uint32_t rawID : 29; 
    uint8_t canFlags : 3; /* <==== Moved */ 
    } __attribute__ ((packed)); 
} __attribute__ ((packed)) idSpecial; 

Updated example on ideone. Ovviamente, quel cambiamento specifico probabilmente non è quello che vuoi; Sto solo dimostrando che il problema sta avviando un nuovo campo non su un limite di byte.

---

* "probabilmente" perché alla fine spetta al compilatore.

Answer 2

In alcuni compilatori, per "unire" i bit, tutti gli elementi devono essere dello stesso tipo. Così lo rendono uint32_t dove ora avete uint8_t - questo sembra non essere il caso nella Ideone compilatore utilizza tho'

[Non importa cosa, E' ancora fino al compilatore come si fonde i bit, quindi è l'unica il modo per garantire assolutamente che i tuoi dati siano memorizzati come 32 bit è usare un singolo uint32_t e dichiarare una classe che fa il relativo shifting e anding/oring per manipolare il valore - l'unica garanzia che hai è che UN elemento nella tua struct avrà almeno tanti bit quanti ne hai richiesti]

Come altri hanno sottolineato, non è possibile avviare una nuova struttura su un limite diverso da un byte. Ho riparato avendo un secondo struct all'interno dell'unione, in questo modo: http://ideone.com/Mr1gjD

#include <stdint.h> 
#include <stdio.h> 

typedef struct structTag { 
    union { 
    struct { 
     uint32_t messageID : 26; /* 26bit message id, 67108864 ids */ 
     uint8_t priority : 3; /* priority: MUST BE 0 */ 
    } __attribute__ ((packed)); 
    struct { 
     uint32_t rawID : 29; 
     uint8_t canFlags : 3; 
    }; 
    } __attribute__ ((packed)); 
} __attribute__ ((packed)) idSpecial; 

int main() { 
    printf("size: %d", sizeof(idSpecial)); 
    return 0; 
} 

Answer 3

Il problema è che __attribute__((packed)) non esegue imballaggio bit. Garantisce solo che non ci sono imbottiture tra i membri struct. Si può provare questo esempio più semplice, dove la dimensione è segnalato anche come 5:

typedef struct structTag { 
    struct { 
     uint32_t messageID : 26; 
     uint8_t priority : 3; 
    } __attribute__ ((packed)); 
    uint8_t canFlags : 3; 
} __attribute__ ((packed)) idSpecial; 

Bitwise imballaggio è possibile solo per i membri BITFIELD. Dovrai riprogettare la tua struct per essere un'unione di una struct con bitfield messageID/priority/canFlags, e una struct con bitfields rowID/canFlags. In altre parole, sarà necessario avere qualche duplicazione o ricorrere alle macro accessorie o alle funzioni membro.

Answer 4

I dati sono disposti e accessibili nella memoria del computer mediante l'allineamento della struttura dei dati. Che ha due questioni correlate

1. allineamento
2. Imbottitura

Quando un'operazione di scrittura viene eseguita da computer, scrive di solito in multiplo di 4 byte (per i sistemi a 32 bit). Una ragione per questo atto è l'obiettivo di aumentare le prestazioni.Pertanto, quando si scrive una struttura dati, che ha prima una variabile da 1 byte e quindi una variabile da 4 byte, eseguirà il riempimento dopo i primi 1 byte di dati per allinearla su limiti a 32 bit.

struct { 
    union { 
    struct { 
     uint32_t messageID : 26; 
     uint8_t priority : 3; 
    } __attribute__ ((packed)); 
    uint32_t rawID : 29; 
    } __attribute__ ((packed)); 
    uint8_t canFlags : 3; 
} __attribute__ ((packed)) idSpecial; 

Ora nella struttura dati sopra riportati si utilizza __attribute__ ((packed)) che significa senza imbottitura. Quindi uint32_t è di 4 byte, ma si sa che ha 26 bit e 3 bit per priorità. Ora, poiché avete entrambe le variabili in una struttura, riserverà 32 bit anziché 29 in modo che le informazioni della prima struttura siano allineate sui limiti.

Ora per canFlags Avrà bisogno di altri byte. Quindi questo rende 5 byte anziché 4.