sizeof a union in C/C++

Question

Qual è la dimensione del sindacato in C/C++? È la dimensione del più grande datatype al suo interno? In tal caso, in che modo il compilatore calcola come spostare il puntatore dello stack se è attivo uno dei tipi di dati più piccoli dell'unione?

Answer 1

Lo standard risponde a tutte le domande nella sezione 9.5 dello standard C++, o sezione 6.5.2.3 paragrafo 5 dello standard C99 (o paragrafo 6 della norma C11):

In un'unione, al massimo uno dei membri di dati può essere attivo in qualsiasi momento, ovvero il valore di al massimo uno dei membri di dati può essere memorizzato in un sindacato in qualsiasi momento. [Nota: viene creata una garanzia speciale per semplificare l'uso dei sindacati: Se un POD-union contiene diverse strutture POD che condividono una sequenza iniziale comune (9.2), e se un oggetto di questo tipo POD-union contiene uno di le strutture POD, è consentito ispezionare la sequenza iniziale comune di uno qualsiasi dei membri di POD-struct; vedi 9.2. ] La dimensione di un sindacato è sufficiente per contenere il più grande dei suoi membri di dati. Ogni membro dei dati viene assegnato come se fosse l'unico membro di una struttura.

Ciò significa che ogni membro condivide la stessa area di memoria. C'è è al massimo un membro attivo, ma non è possibile scoprire quale. Dovrai memorizzare le informazioni sul membro attualmente attivo da qualche altra parte. Memorizzare una tale bandiera oltre al sindacato (per esempio avere una struct con un intero come type-flag e un union come data-store) ti darà una cosiddetta "unione discriminata": un'unione che sa di che tipo è attualmente "attivo".

Un uso comune è in lexer, dove si può avere diversi gettoni, ma a seconda del modo, si hanno diverse informazioni per memorizzare (mettendo line in ogni struttura per mostrare ciò che una sequenza iniziale comune è):

struct tokeni { 
    int token; /* type tag */ 
    union { 
     struct { int line; } noVal; 
     struct { int line; int val; } intVal; 
     struct { int line; struct string val; } stringVal; 
    } data; 
}; 

Lo standard consente di accedere a line di ciascun membro, poiché questa è la sequenza iniziale comune di ciascun membro.

Esistono estensioni del compilatore che consentono l'accesso a tutti i membri ignorando il valore attualmente memorizzato. Ciò consente una reinterpretazione efficiente dei bit memorizzati con tipi diversi tra i membri. Ad esempio, possono essere utilizzati per sezionare una variabile float in 2 pantaloncini firmati:

union float_cast { unsigned short s[2]; float f; }; 

che può venire molto utile quando si scrive codice di basso livello. Se il compilatore non supporta quell'estensione, ma lo fai comunque, scrivi un codice i cui risultati non sono definiti. Quindi assicurati che il compilatore lo supporti se usi questo trucco.

Answer 2

A union occupa sempre lo spazio del membro più grande. Non importa ciò che è attualmente in uso.

union { 
    short x; 
    int y; 
    long long z; 
} 

Un esempio di quanto sopra union sarà sempre prendere almeno un long long per la conservazione.

Nota a margine: Come notato da Stefano, lo spazio effettivo qualsiasi tipo (union, struct, class) assumerà non dipendono da altri problemi come l'allineamento dal compilatore. Non l'ho passato per semplicità perché volevo solo dire che un sindacato prende in considerazione il più grande oggetto. È importante sapere che la dimensione effettiva corrisponde a dipende dall'allineamento.

Answer 3

Non esiste alcuna nozione di tipo di dati attivo per un'unione. Sei libero di leggere e scrivere qualsiasi "membro" dell'unione: spetta a te interpretare ciò che ottieni.

Pertanto, la dimensione di un'unione è sempre la dimensione del suo più grande tipo di dati.

Answer 4

La dimensione sarà almeno quella del più grande tipo di composizione. Non esiste un concetto di tipo "attivo".

Answer 5

Si dovrebbe davvero considerare un unione come un contenitore per il tipo di dati più grande al suo interno combinato con una scorciatoia per un cast. Quando si utilizza uno dei membri più piccoli, lo spazio non utilizzato è ancora lì, ma rimane semplicemente inutilizzato.

Si vede spesso questo usato in combinazione con le chiamate ioctl() in Unix, tutte le chiamate ioctl() passeranno la stessa struttura, che contiene un'unione di tutte le possibili risposte. Per esempio. questo esempio proviene da /usr/include/linux/if.h e questa struct è usata in ioctl() per configurare/interrogare lo stato di un'interfaccia ethernet, i parametri di richiesta definiscono quale parte del sindacato è effettivamente in uso :

struct ifreq 
{ 
#define IFHWADDRLEN 6 
    union 
    { 
     char ifrn_name[IFNAMSIZ];  /* if name, e.g. "en0" */ 
    } ifr_ifrn; 

    union { 
     struct sockaddr ifru_addr; 
     struct sockaddr ifru_dstaddr; 
     struct sockaddr ifru_broadaddr; 
     struct sockaddr ifru_netmask; 
     struct sockaddr ifru_hwaddr; 
     short ifru_flags; 
     int ifru_ivalue; 
     int ifru_mtu; 
     struct ifmap ifru_map; 
     char ifru_slave[IFNAMSIZ]; /* Just fits the size */ 
     char ifru_newname[IFNAMSIZ]; 
     void * ifru_data; 
     struct if_settings ifru_settings; 
    } ifr_ifru; 
}; 

Answer 6

1. la dimensione del più grande membro.

2. Ecco perché i sindacati di solito hanno senso all'interno di una struttura che ha una bandiera che indica quale è il membro "attivo".

Esempio:

struct ONE_OF_MANY { 
    enum FLAG { FLAG_SHORT, FLAG_INT, FLAG_LONG_LONG } flag; 
    union { short x; int y; long long z; }; 
}; 

Answer 7

Dipende dal compilatore, e sulle opzioni.

int main() { 
    union { 
    char all[13]; 
    int foo; 
    } record; 

printf("%d\n",sizeof(record.all)); 
printf("%d\n",sizeof(record.foo)); 
printf("%d\n",sizeof(record)); 

} 

This uscite:

Se ricordo bene, dipende dall'allineamento che il compilatore mette nello spazio assegnato.Quindi, a meno che tu non usi qualche opzione speciale, il compilatore inserirà il padding nello spazio dell'unione.

edit: con gcc è necessario utilizzare una direttiva pragma

int main() { 
#pragma pack(push, 1) 
     union { 
      char all[13]; 
      int foo; 
     } record; 
#pragma pack(pop) 

     printf("%d\n",sizeof(record.all)); 
     printf("%d\n",sizeof(record.foo)); 
     printf("%d\n",sizeof(record)); 

} 

questa uscita

si può vedere anche dal smontare (rimosso alcune printf, per chiarezza)

0x00001fd2 <main+0>: push %ebp    | 0x00001fd2 <main+0>: push %ebp 
    0x00001fd3 <main+1>: mov %esp,%ebp  | 0x00001fd3 <main+1>: mov %esp,%ebp 
    0x00001fd5 <main+3>: push %ebx    | 0x00001fd5 <main+3>: push %ebx 
    0x00001fd6 <main+4>: sub $0x24,%esp  | 0x00001fd6 <main+4>: sub $0x24,%esp 
    0x00001fd9 <main+7>: call 0x1fde <main+12> | 0x00001fd9 <main+7>: call 0x1fde <main+12> 
    0x00001fde <main+12>: pop %ebx    | 0x00001fde <main+12>: pop %ebx 
    0x00001fdf <main+13>: movl $0xd,0x4(%esp) | 0x00001fdf <main+13>: movl $0x10,0x4(%esp)           
    0x00001fe7 <main+21>: lea 0x1d(%ebx),%eax | 0x00001fe7 <main+21>: lea 0x1d(%ebx),%eax 
    0x00001fed <main+27>: mov %eax,(%esp)  | 0x00001fed <main+27>: mov %eax,(%esp) 
    0x00001ff0 <main+30>: call 0x3005 <printf> | 0x00001ff0 <main+30>: call 0x3005 <printf> 
    0x00001ff5 <main+35>: add $0x24,%esp  | 0x00001ff5 <main+35>: add $0x24,%esp 
    0x00001ff8 <main+38>: pop %ebx    | 0x00001ff8 <main+38>: pop %ebx 
    0x00001ff9 <main+39>: leave     | 0x00001ff9 <main+39>: leave 
    0x00001ffa <main+40>: ret      | 0x00001ffa <main+40>: ret  

Dove l'unica differenza è nel main + 13, dove il compilatore alloca sullo stack 0xd invece di 0x10

Answer 8

Qual è la dimensione dell'unione in C/C++? La dimensione del più grande tipo di dati al suo interno?

Sì, La dimensione del sindacato è la dimensione del suo più grande membro.

Per esempio:

#include<stdio.h> 

union un 
{ 
    char c; 
    int i; 
    float f; 
    double d; 
}; 

int main() 
{ 
    union un u1; 
    printf("sizeof union u1 : %ld\n",sizeof(u1)); 
    return 0; 
} 

uscita:

sizeof union u1 : 8 
sizeof double d : 8 

Ecco il più grande membro è double. Entrambi hanno la dimensione 8. Quindi, come correttamente detto sizeof, la dimensione dell'unione è effettivamente 8.

in che modo il compilatore calcola come spostare il puntatore dello stack se uno del tipo di dati più piccolo dell'unione è attivo?

Gestisce internamente dal compilatore. Supponiamo che stiamo accedendo a uno dei membri di unione dati, quindi non possiamo accedere ad altri membri dati poiché possiamo accedere a singoli membri di unione dati poiché ogni membro di dati condivide la stessa memoria. Usando Union possiamo salvare un sacco di spazio prezioso.