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:

Byte 0 Byte 1 Byte 2 Byte 3 Byte 4 Byte 5 Byte 6 Byte 7
A
B
C

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

Byte 0 Byte 1 Byte 2 Byte 3 Byte 4 Byte 5 Byte 6 Byte 7 Byte 8 Byte 9 Byte 10 Byte 11 Byte 12
A B C

Nota: Unas notas sobre el ejemplo:
• Observa que hemos hecho un "casting" del puntero al elemento B de la unión. Si no lo hiciéramos así, cout encontraría un puntero a char, que se considera como una cadena, y por defecto intentaría imprimir la cadena, pero nosotros queremos imprimir el puntero, así que lo convertimos a un puntero de otro tipo.
• Observa que el tamaño de la unión es el del elemento más grande.

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 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.

Comentarios de los usuarios (10)

Julián Lopera B
2013-08-04 05:33:24

Hola,

Estuve viendo la tan interesante información que pones sobre las uniones, y bueno, me gustaría participar con una pregunta, tal vez sea de interés para muchos, espero que asi sea.

Me he topado con el siguiente código.

typedef union {
  byte Byte;
  struct {
    byte PTAD0       :1;                                       /* Port A Data Register Bit 0 */
    byte PTAD1       :1;                                       /* Port A Data Register Bit 1 */
    byte PTAD2       :1;                                       /* Port A Data Register Bit 2 */
    byte PTAD3       :1;                                       /* Port A Data Register Bit 3 */
    byte PTAD4       :1;                                       /* Port A Data Register Bit 4 */
    byte PTAD5       :1;                                       /* Port A Data Register Bit 5 */
    byte             :1; 
    byte             :1; 
  } Bits;
  struct {
    byte grpPTAD :6;
    byte         :1;
    byte         :1;
  } MergedBits;
} PTADSTR;
extern volatile PTADSTR _PTAD @0x00000000;

Me preocupa no tener muy claro para que sirve en este caso el operador '' : " y en la parte inferior del código no entiendo para que usar el " @ " y el número hexadecimal.

A propósito, que entretenido curso. Felicitaciones.

Salvador Pozo
2013-08-05 20:38:17

Hola Julián:

El operador ":", en este caso, sirve para definir campos de bits. Eso se vio en el capítulo 11:

http://c.conclase.net/curso/?cap=011b#STR_CamposBits

La unión que muestras puede servir para manejar un byte (ocho bits), en conjunto, o bien cada uno de los seis bits de menor peso por separado, o los seis juntos.

En cuanto a la declaración final:

extern volatile PTADSTR _PTAD @0x00000000;

Lo que declara es un puntero externo que apunta a la dirección 0. La '@' es el operador de indirección, es decir, obtiene un puntero.

En C++ estándar esto no es legal: aplicar el operador @ a una constante, pero imagino que este código está escrito para algún tipo de procesador, y el compilador no sigue el estándar al pié de la letra.

Hasta pronto.

Milton Parra
2014-04-18 21:25:50

Saludos. En su explicación de los temas ESTRUCTURAS y UNIONES dicen que las palabras STRUC y UNION son ambas opcionales en C++. Mi inquietud según lo que entiendo es la siguiente:

struct persona{char nombre[30], int edad} //Guarda ambos campos.

union persona{char nombre[30], int edad} //Guarda el nombre o la edad pero no ambos.

Podrían decirme dónde estoy equivocado?. Gracias

Steven R. Davidson
2014-04-18 22:10:14

Hola Milton,

Son optativas para la declaración y definición de las variables; o sea,

struct Algo { int num; };

Algo var;  // No hace falta indicar 'struct'

Antes de ver tu ejemplo, tengo que corregirlo un poco:

// Guarda ambos campos.
struct persona
{
  char nombre[30];
  int edad;
};

// Guarda el nombre o la edad pero no ambos.
union persona
{
  char nombre[30];
  int edad;
};

Estás en lo correcto, pero quiero aclarar el comentario de la unión. Puedes pensar que tenemos un solo campo, que en este caso consiste de 30 bytes, ya que 'nombre' ocupa más bytes que 'edad'. Accedemos a los datos a través de uno de dos nombres - 'nombre' o 'edad' - que cada uno implica la forma de interpretar tales datos: o como una cadena de caracteres o como un entero.

Espero que haya aclarado la duda.

Steven

Milton Parra
2014-04-19 01:12:23

Gracias Steven, por la respuesta y la aclaración.

pablo
2014-06-15 11:45:33

Hola, y ante todo muchas gracias por el curso. Estoy aprendiendo mucho.

Mi duda es sobre el operador @. No lo entiendo y no encuentro información sobre el.

Le respondisteis a Julian esto:

"En cuanto a la declaración final:

extern volatile PTADSTR _PTAD @0x00000000;

Lo que declara es un puntero externo que apunta a la dirección 0. La '@' es el operador de indirección, es decir, obtiene un puntero."

El operador de indirección he aprendido en este curso que es * y que define un puntero o muestra el objeto apuntado por un puntero.

No entiendo si @ es equivalente a *. Para declarar un puntero que apunte a la dirección 0 yo lo intentaría asi:

extern volatile PTADSTR *_PTAD = 0x00000000;

Tampoco entiendo como se puede obtener la dirección de una dirección.

No sé, hay algo que no entiendo. Si me pudieras ayudar a entenderlo te lo agradecería.

Un cordial saludo.

Steven R. Davidson
2014-06-15 16:31:26

Hola Pablo,

El símbolo @ no pertenece al estándar de los lenguajes de C ni de C++. La explicación de Salvador se refería al uso (no estándar) del compilador usado para compilar tal código fuente. Personalmente, he visto varios compiladores especiales para microntroladores que hacen uso del símbolo @ como un operador en su versión extendida de C/C++, como por ejemplo, para Arduino.

Espero que esto aclare la duda.

Steven

Fabio
2015-10-27 15:58:43

Hola, felicitaciones por el curso.

Soy programador avanzado en C# y aunque comencé programando en C se me han olvidado varios conceptos, y este curso me ha servido de mucho.

Una observación sobre la explicación que das de la forma de almacenamiento entre unión y struct, después del int y el char debería haber un padding, y así el struct usaría no 13 bytes sino 24 o 16 según el compilador.. (puede que me esté adelantando mucho con el tema de la memoria).

Tengo una duda sobre la unión, teniendo el siguiente ejemplo:

union unionEjemplo{
  char a;
  unsigned short int b;
} C;

int main(){
  C.b = 10000;
  cout << C.a;
}

En este caso sabemos que la unión tiene un tamaño de 16 bits (o 2 bytes) por el tamaño del short int, al asignarle el valor a C.b de 10000 (en bits 0010011100010000), luego que pasaría al imprimir C.a ?,

-Debería arrojar 0 (cero) porque C.a no tiene valor? (por lo que entendí no debería pasar ya que en memoria si hay un valor, el asignado a C.b)

-Debería arrojar un error porque el largo de datos (2 bytes) es mayor al admitido por char (1 byte)?

-Internamente se produce un cast o parse, cortando los 2 bytes en 1, y se pierde la otra mitad?, si esto sucediera, que byte imprime, el primero (00100111) y muestra un ', o el segundo (00010000) y muestra un carácter de sistema?

De antemano gracias, ahora no puedo hacer el ejemplo por mi propia cuenta ya que estoy lejos de mi pc.

Saludos.

Steven R. Davidson
2015-10-27 17:39:02

Hola Fabio,

Efectivamente, cometimos un error y debería ser 16 bytes, ya que se tomaría el campo C de tipo 'double' como el alineamiento por ocupar el mayor tamaño. Esto implica que los dos primeros campos, 'A' y 'B', caben en un bloque de 8 bytes, quedando 3 bytes inutilizados.

En cuanto a tu duda, la respuesta es que toma la información (la secuencia de bits) en memoria para crear un 'char'. En tu ejemplo, se toma la secuencia en el primer byte de 'C' que coincide con el miembro 'a'. Por lo tanto, 'C.a' contiene el valor de 39, que en binario es: 001000111. Como el tipo es 'char', 'cout <<' interpretará 39 como un carácter y como bien dices imprimirá una comilla singular.

Sin embargo, esto realmente depende de la arquitectura del procesador que ejecuta el programa. Si usas un procesador de Intel (o compatible) entonces vas a tener el otro resultado que comentas: 8 que en binario es: 00010000. Esto es porque el orden de los bytes es de la menor importancia a la mayor. En memoria, la secuencia, 0010011100010000, se ordenaría así:

00010000 | 00100111

Por lo tanto, en una arquitectura de Intel (o compatible), el primer byte contiene la secuencia: 00010000 y por consiguiente, se aplicará el carácter 8 de control, que es el de retroceso en ASCII.

Este tema es muy parecido al de las estructuras con campos de bits. Cada "campo" trata los bits de una forma diferente. En el caso de la unión, podemos interpretar cada secuencia de bits de una forma diferente según el tipo del campo definido. La idea principal es que podemos unificar diferentes tipos bajo un solo tipo de dato (la unión en sí) reusando la misma memoria.

Espero haber aclarado las dudas.

Steven

Jose
2017-08-15 06:08:30

saludos

me han interesado los temas que se tratan sobre programación y para aprovechar la ocasión, quiero saber que valor en byte tiene una unión que tiene varias estructuras declaradas en los campos, pues pensaba que deberían ser el valor de la estructura mas grande y como no puedo acceder a los dos campos a la vez se escoge el campo con la estructura de mayor valor en byte, por tal razón pensé que es el de la estructuras que ocupa mas espacio en byte.

gracias.