16 Tipos de variables V: Uniones

Las uniones son un tipo especial de estructuras que permiten almacenar elementos de diferentes tipos en las mismas posiciones de memoria, aunque evidentemente no simultáneamente.

Sintaxis:

union [<identificador>] {
   [<tipo> <nombre_variable>[,<nombre_variable>,...]];
} [<variable_union>[,<variable_union>,...];

El identificador de la unión es un nombre opcional para referirse a la unión.

Las variables de unión son objetos declarados del tipo de la unión, y su inclusión también es opcional.

Sin embargo, como en el caso de las estructuras, al menos uno de estos elementos debe existir, aunque ambos sean opcionales.

En el interior de una unión, entre las llaves, se pueden definir todos los elementos necesarios, del mismo modo que se declaran los objetos. La particularidad es que cada elemento se almacenará comenzando en la misma posición de memoria.

Las uniones pueden referenciarse completas, usando su nombre, como hacíamos con las estructuras, y también se puede acceder a los elementos en el interior de la unión usando el operador de selección (.), un punto.

También pueden declararse más objetos del tipo de la unión en cualquier parte del programa, de la siguiente forma:

[union] <identifiador_de_unión> <variable>[,<variable>...]; 

La palabra clave union es opcional en la declaración de objetos en C++. Aunque en C es obligatoria.

Ejemplo:

#include <iostream>
using namespace std;

union unEjemplo {
   int A;
   char B;
   double C;
} UnionEjemplo;

int main() {
   UnionEjemplo.A = 100;
   cout << UnionEjemplo.A << endl;
   UnionEjemplo.B = 'a';
   cout << UnionEjemplo.B << endl;
   UnionEjemplo.C = 10.32;
   cout << UnionEjemplo.C << endl;
   cout << &UnionEjemplo.A << endl;
   cout << (void*)&UnionEjemplo.B << endl;
   cout << &UnionEjemplo.C << endl;
   cout << sizeof(unEjemplo) << endl;
   cout << sizeof(UnionEjemplo.A) << endl;
   cout << sizeof(UnionEjemplo.B) << endl;
   cout << sizeof(UnionEjemplo.C) << endl;

   return 0;
}

Supongamos que en nuestro ordenador, int ocupa cuatro bytes, char un byte y double ocho bytes. La forma en que se almacena la información en la unión del ejemplo sería la siguiente:

Por el contrario, los mismos objetos almacenados en una estructura tendrían la siguiente disposición:

Veamos otro ejemplo, pero éste más práctico. Algunas veces tenemos estructuras que son elementos del mismo tipo, por ejemplo X, Y, y Z todos enteros. Pero en determinadas circunstancias, puede convenirnos acceder a ellos como si fueran un array: Coor[0], Coor[1] y Coor[2]. En este caso, la unión puede resultar útil:

struct stCoor3D {
   int X, Y, Z;
};

union unCoor3D {
   struct stCoor3D N;
   int Coor[3];
} Punto;

Con estas declaraciones, en nuestros programas podremos referirnos a la coordenada Y de estas dos formas:

Punto.N.Y
Punto.Coor[1]

Estructuras anónimas

Como ya vimos en el capítulo sobre estructuras, una {cc:011b#STR_Anonimas:estructura anónima} es la que carece de identificador de tipo de estructura y de identificador de variables del tipo de estructura.

Por ejemplo, la misma unión del último ejemplo puede declararse de este otro modo:

union unCoor3D {
   struct {
      int X, Y, Z;
   };
   int Coor[3];
} Punto;

Haciéndolo así accedemos a la coordenada Y de cualquiera de estas dos formas:

Punto.Y
Punto.Coor[1]

Usar estructuras anónimas dentro de una unión tiene la ventaja de que nos ahorramos escribir el identificador de la estructura para acceder a sus campos. Esto no sólo es útil por el ahorro de código, sino sobre todo, porque el código es mucho más claro.

Inicialización de uniones

Las uniones solo pueden ser inicializadas en su declaración mediante su primer miembro.

Por ejemplo, en la primera unión:

union unEjemplo {
   int A;
   char B;
   double C;
} UnionEjemplo;

Podemos iniciar objetos de este tipo asignando un entero:

unEjemplo x = {10}; // int
unEjemplo y = {'a'}; // char
unEjemplo z = {10.02}; // double

Si usamos un carácter, como en el caso de 'y', se hará una conversión de tipo a int de forma automática, y se asignará el valor correcto. En el caso de 'z', se produce un aviso, por democión automática.

Quiero llamar tu atención sobre el modo de inicializar uniones. Al igual que pasa con otros tipos agregados, como arrays y estructuras, hay que usar llaves para incluir una lista de valores iniciales. En el caso de la unión, esa lista tendrá un único elemento, ya que todos los miembros comparten la misma zona de memoria, y sólo está permitido usar el primero para las inicializaciones.

Discriminadores

Supongamos que necesitamos almacenar en un array datos de diferentes tipos, nos importa más almacenarlos todos en la misma estructura. Por ejemplo, en la gestión de una biblioteca queremos crear una tabla que contenga, de forma indiscriminada, libros, revistas y películas.

Podemos crear una unión, ejemplar, que contenga un elemento de cada tipo, y después un array de ejemplares.

struct tipoLibro {
    int codigo;
    char autor[80];
    char titulo[80];
    char editorial[32];
    int anno;
};

struct tipoRevista {
    int codigo;
    char nombre[32];
    int mes;
    int anno;
};

struct tipoPelicula {
    int codigo;
    char titulo[80];
    char director[80];
    char productora[32];
    int anno;
};

union tipoEjemplar {
    tipoLibro l;
    tipoRevista r;
    tipoPelicula p;
};

tipoEjemplar tabla[100];

Pero hay un problema, del que quizás ya te hayas percatado...

Cuando accedamos a un elemento de la tabla, ¿cómo sabemos si contiene un libro, una revista o una película?

Lo que se suele hacer es añadir un elemento más que indique qué tipo de dato contiene la unión. A ese elemento se le llama discriminador:

enum eEjemplar { libro, revista, pelicula };

struct tipoEjemplar {
    eEjemplar tipo;
    union {
        tipoLibro l;
        tipoRevista r;
        tipoPelicula p;
    };
};

Usando el discriminador podemos averiguar qué tipo de publicación estamos manejando, y mostrar o asignar los valores adecuados.

Funciones dentro de uniones

Como en el caso de las estructuras, en las uniones también se pueden incluir como miembros funciones, constructores y destructores.

Del mismo modo, es posible crear tantos constructores como se necesiten. En cuanto a este aspecto, las estructuras y uniones son equivalentes.

Según la norma ANSI, todos los campos de las uniones deben ser públicos, y no se permiten los modificadores private y protected.

Un objeto que tenga constructor o destructor no puede ser utilizado como miembro de una unión. Esta limitación tiene su lógica, puesto que la memoria de cada elemento de una unión se comparte, no tendría sentido que los constructores de algunos elementos modificasen el contenido de esa memoria, ya que afectan directamente a los valores del resto de los elementos.

Una unión no puede participar en la jerarquía de clases; no puede ser derivada de ninguna clase, ni ser una clase base. Aunque sí pueden tener un constructor y ser miembros de clases.

Palabras reservadas usadas en este capítulo

union.

Ejemplos capítulo 16

Ejemplo 16.1

Una aplicación clásica de las uniones es ofrecer la posibilidad de manipular los mismos datos de formas diferentes. Por ejemplo, podemos crear una unión para manipular un byte a tres niveles: completo, bit a bit o nibble a nibble. (Un nibble es un conjunto de cuatro bits).

#include <iostream>
#include <cstdio>

using namespace std;

union byte {
    unsigned char b;
    struct {
        unsigned char bit8:1;
        unsigned char bit7:1;
        unsigned char bit6:1;
        unsigned char bit5:1;
        unsigned char bit4:1;
        unsigned char bit3:1;
        unsigned char bit2:1;
        unsigned char bit1:1;
    };
    struct {
        unsigned char nibble2:4;
        unsigned char nibble1:4;
    };
};

int main() {
    byte x;

    x.b = 0x2a;

    printf("%d\n", x.bit1);
    printf("%d\n", x.bit2);
    printf("%d\n", x.bit3);
    printf("%d\n", x.bit4);
    printf("%d\n", x.bit5);
    printf("%d\n", x.bit6);
    printf("%d\n", x.bit7);
    printf("%d\n", x.bit8);

    printf("%x\n", x.nibble1);
    printf("%x\n", x.nibble2);

    x.bit2 = 1;
    x.bit3 = 0;
    printf("%02x\n", x.b);

    return 0;
}

Ejecutar este código en OnlineGDB.

Ejemplo 16.2

En los ordenadores, por norma general, se usan números para codificar colores. Los dispositivos gráficos usan la síntesis aditiva de color. Partiendo de los colores básicos: rojo, azul y verde, se puede obtener cualquier color combinandolos en diferentes proporciones.

También por norma general, se suelen usar ocho bits para cada color, como hay tres componentes, eso da un total de 24 bits. En una palabra de 32 bits sobrarían ocho. A veces, esos ocho bits se usan como componente alfa, que indica la transparencia, o cómo se combina el color con el que existía previamente en ese punto.

En un valor entero de 32 bits, se usan los ocho de menor peso para codificar el valor del color rojo. Se suele usar la letra 'R' (Red=Rojo). En los ocho bits siguientes se codifica el color verde. Se usa la letra 'G' (Green=Verde). En los ocho siguientes se codifica el azul. Se usa la letra 'B' (Blue=Azul). Estos tres valores codifican un color en formato RGB.

Si se usan los 32 bits, los ocho restantes codifican la componente Alfa (Alpha), de transparencia.

Algunas aplicaciones y funciones de los APIs trabajan con enteros de 32 bits para manejar colores, pero a menudo es interesante acceder los componentes básicos directamente.

Podemos crear una unión para codificar colores según estas reglas, y que además de que nos permitan manipular el color como un valor único, podamos acceder a los componentes por separado:

#include <iostream>

using namespace std;

union color {
    unsigned int c;
    struct {
        unsigned char red;
        unsigned char green;
        unsigned char blue;
        unsigned char alpha;
    };
};

int main() {
    color c1 = { 0x80fedc12 };

    cout << "Color: " << dec << c1.c << " - " << hex << c1.c << endl;
    cout << "Rojo:  " << dec << (int)c1.red << " - " << hex << (int)c1.red << endl;
    cout << "Verde: " << dec << (int)c1.green << " - " << hex << (int)c1.green << endl;
    cout << "Azul:  " << dec << (int)c1.blue << " - " << hex << (int)c1.blue << endl;
    cout << "Alfa:  " << dec << (int)c1.alpha << " - " << hex << (int)c1.alpha << endl;

    c1.red = 0x42;
    c1.green = 0xde;
    cout << "Color: " << dec << c1.c << " - " << hex << c1.c << endl;
    cout << "Rojo:  " << dec << (int)c1.red << " - " << hex << (int)c1.red << endl;
    cout << "Verde: " << dec << (int)c1.green << " - " << hex << (int)c1.green << endl;
    cout << "Azul:  " << dec << (int)c1.blue << " - " << hex << (int)c1.blue << endl;
    cout << "Alfa:  " << dec << (int)c1.alpha << " - " << hex << (int)c1.alpha << endl;

    return 0;
}

Ejecutar este código en OnlineGDB.

Ejemplo 16.3

Veamos ahora cómo usar funciones dentro de uniones.

Para este ejemplo crearemos un constructor para cada tipo de dato que contenga la unión. Esto nos permitirá evitar la limitación de la inicialización de objetos de este tipo, ya que el compilador eligirá el constructor adecuado en función del valor suministrado.

Podemos reinterpretar, entonces, la regla que dice que sólo podemos inicializar uniones usando el primer elemento.

En realidad, lo que pasa es que el compilador sólo crea un constructor por defecto para las uniones y que el parámetro elegido para ese constructor es el primero. Nada nos impide, pues, crear nuestros propios constructores para modificar el comportamiento predefinido.

#include <iostream>
#include <cstring>

using namespace std;

union ejemplo {
    int x;
    double d;
    char cad[8];
    ejemplo(int i) : x(i) {}
    ejemplo(double n) : d(n) {}
    ejemplo(const char *c) {
        strncpy(cad, c, 7);
        cad[7] = 0;
    }
};

int main() {
    ejemplo A(23);
    ejemplo B(123.323);
    ejemplo C("hola a todos");

    cout << "A: " << A.x << endl;
    cout << "B: " << B.d << endl;
    cout << "C: " << C.cad << endl;

    return 0;
}

Ejecutar este código en OnlineGDB.

Vemos en el ejemplo que se puede invocar a los constructores de la forma normal, o implícitamente, como en el caso del objeto D, para el que se suministra una cadena, que evidentemente, no es el tipo del primer elemento de la unión.

Ejemplo 16.4

Vamos a completar el ejemplo de los discriminadores, añadiendo código para iniciar y visualizar elementos del array.

// Ejemplo de unión con discriminador
// 2009 Con Clase, Salvador Pozo
#include <iostream>
#include <cstring>

using namespace std;

struct tipoLibro {
    int codigo;
    char autor[80];
    char titulo[80];
    char editorial[32];
    int anno;
};

struct tipoRevista {
    int codigo;
    char nombre[32];
    int mes;
    int anno;
};

struct tipoPelicula {
    int codigo;
    char titulo[80];
    char director[80];
    char productora[32];
    int anno;
};

enum eEjemplar { libro, revista, pelicula };

struct tipoEjemplar {
    eEjemplar tipo;
    union {
        tipoLibro l;
        tipoRevista r;
        tipoPelicula p;
    };
};

tipoEjemplar tabla[100];

int main() {
    tabla[0].tipo = libro;
    tabla[0].l.codigo = 3;
    strcpy(tabla[0].l.titulo, "El señor de los anillos");
    strcpy(tabla[0].l.autor, "J.R.R. Tolkien");
    tabla[0].l.anno = 1954;

    tabla[1].tipo = revista;
    tabla[1].r.codigo = 12;
    strcpy(tabla[1].r.nombre, "National Geographic");
    tabla[1].r.mes = 11;
    tabla[1].r.anno = 2009;

    tabla[2].tipo = pelicula;
    tabla[2].p.codigo = 43;
    strcpy(tabla[2].p.titulo, "Blade Runner");
    strcpy(tabla[2].p.director, "Ridley Scott");
    strcpy(tabla[2].p.productora, "Warner Bros. Pictures");
    tabla[2].l.anno = 1982;

    for(int i=0; i < 3; i++) {
        switch(tabla[i].tipo) {
            case libro:
                cout << "[" << tabla[i].l.codigo << "] Libro titulo: " << tabla[i].l.titulo << endl;
                break;
            case revista:
                cout << "[" << tabla[i].r.codigo << "] Revista nombre: " << tabla[i].r.nombre << endl;
                break;
            case pelicula:
                cout << "[" << tabla[i].p.codigo << "] Pelicula titulo: " << tabla[i].p.titulo << endl;
                break;
        }
    }
    return 0;
}

Ejecutar este código en OnlineGDB.