Union declaration

Una unión es un tipo que consiste en una secuencia de miembros cuyo almacenamiento se superpone (a diferencia de struct, que es un tipo que consiste en una secuencia de miembros cuyo almacenamiento se asigna en una secuencia ordenada). El valor de como máximo uno de los miembros puede almacenarse en una unión en cualquier momento.

El especificador de tipo para una unión es idéntico al struct especificador de tipo excepto por la palabra clave utilizada:

Sintaxis

Explicación

La unión solo es tan grande como es necesario para contener su miembro más grande (también se puede agregar relleno adicional sin nombre al final). Los otros miembros se asignan en los mismos bytes como parte de ese miembro más grande.

Un puntero a una unión puede convertirse a un puntero a cada uno de sus miembros (si una unión tiene miembros de campo de bits, el puntero a la unión puede convertirse al puntero al tipo subyacente del campo de bits). Del mismo modo, un puntero a cualquier miembro de una unión puede convertirse a un puntero a la unión que lo contiene.

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

Palabras clave

union

Notas

Consulte inicialización de estructuras para conocer las reglas sobre la inicialización de estructuras y uniones.

Ejemplo

#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 es ahora el miembro activo
    printf("La unión S tiene tamaño %zu y contiene %x\n", sizeof s, s.u32);
    s.u16[0] = 0x0011;  // s.u16 es ahora el miembro activo
    // leer desde s.u32 o desde s.u8 reinterpreta la representación del objeto
//  printf("s.u8 es ahora %x\n", s.u8); // no especificado, típicamente 11 o 00
//  printf("s.u32 es ahora %x\n", s.u32); // no especificado, típicamente 12340011 o 00115678
    // los punteros a todos los miembros de una unión se comparan iguales a sí mismos y a la unión
    assert((uint8_t*)&s == &s.u8);
    // esta unión tiene 3 bytes de relleno final
    union pad
    {
        char  c[5]; // ocupa 5 bytes
        float f;    // ocupa 4 bytes, impone alineación 4
    } p = { .f = 1.23 }; // el tamaño es 8 para satisfacer la alineación de float
    printf("tamaño de la unión de char[5] y float es %zu\n", sizeof p);
}

La unión S tiene tamaño 4 y contiene 12345678
tamaño de la unión de char[5] y float es 8

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C publicados anteriormente.

Referencias

Véase también