4z3o1d
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 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;
};
|
Pero hay un problema, del que quizás ya te hayas percatado...
Cuando accedemos 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 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 de clases.
Palabras reservadas usadas en este capítulo
union.
