Union declaration

Une union est un type constitué d'une séquence de membres dont le stockage se chevauche (par opposition à struct, qui est un type constitué d'une séquence de membres dont le stockage est alloué dans une séquence ordonnée). La valeur d'au plus un des membres peut être stockée dans une union à un moment donné.

Le spécificateur de type pour une union est identique au struct spécificateur de type sauf pour le mot-clé utilisé :

Syntaxe

Explication

L'union est seulement aussi grande que nécessaire pour contenir son plus grand membre (un remplissage de fin non nommé supplémentaire peut également être ajouté). Les autres membres sont alloués dans les mêmes octets dans le cadre de ce plus grand membre.

Un pointeur vers une union peut être converti en un pointeur vers chacun de ses membres (si une union a des membres de champ de bits, le pointeur vers l'union peut être converti en pointeur vers le type sous-jacent du champ de bits). De même, un pointeur vers n'importe quel membre d'une union peut être converti en un pointeur vers l'union englobante.

struct v
{
   union // anonymous union
   {
       struct { int i, j; }; // anonymous structure
       struct { long k, l; } w;
   };
   int m;
} v1;
v1.i = 2;   // valid
v1.k = 3;   // invalid: inner structure is not anonymous
v1.w.k = 5; // valid

Mots-clés

union

Notes

Voir l'initialisation des structures pour les règles concernant l'initialisation des structures et des unions.

Exemple

#include <assert.h>
#include <stdint.h>
#include <stdio.h>
int main(void)
{
    union S
    {
        uint32_t u32;
        uint16_t u16[2];
        uint8_t  u8;
    } s = {0x12345678}; // s.u32 est maintenant le membre actif
    printf("L'union S a une taille de %zu et contient %x\n", sizeof s, s.u32);
    s.u16[0] = 0x0011;  // s.u16 est maintenant le membre actif
    // la lecture de s.u32 ou s.u8 réinterprète la représentation objet
//  printf("s.u8 vaut maintenant %x\n", s.u8); // non spécifié, typiquement 11 ou 00
//  printf("s.u32 vaut maintenant %x\n", s.u32); // non spécifié, typiquement 12340011 ou 00115678
    // les pointeurs vers tous les membres d'une union sont égaux entre eux et à l'union
    assert((uint8_t*)&s == &s.u8);
    // cette union a 3 octets de remplissage final
    union pad
    {
        char  c[5]; // occupe 5 octets
        float f;    // occupe 4 octets, impose un alignement de 4
    } p = { .f = 1.23 }; // la taille est 8 pour satisfaire l'alignement de float
    printf("taille de l'union de char[5] et float est %zu\n", sizeof p);
}

L'union S a une taille de 4 et contient 12345678
taille de l'union de char[5] et float est 8

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C publiées antérieurement.

Références

Voir aussi