Uniones

Una unin es un tipo de datos derivado, como una estructura, con miembros
que comparten el mismo espacio de almacenamiento. Una variable de tipo
unin puede contener (en momentos diferentes) objetos de diferentes tipos
y tamaos. Las uniones proporcionan una forma de manipular diferentes
clases de datos dentro de una sola rea de almacenamiento. En cualquier
momento una unin puede contener un mximo de un objeto debido a que
los miembros de una unin comparten el espacio de almacenamiento.
La definicin de "unin" es similar a la de "estructura", La diferencia entre
las dos es que en una estructura, los miembros ocupan diferentes reas de
la memoria, pero en una unin, los miembros ocupan la misma rea de
memoria. Ejemplo:
union [nombre_union] {
campo_1;
campo_2;
... } [variable_union];
El programador puede acceder a travs de "u.i" o de "u.d", pero no de
ambos al mismo tiempo. Como "u.i" y "u.d" ocupan la misma rea de
memoria, modificar uno modificar tambin el valor del otro, algunas veces
de maneras impredecibles. El tamao de una unin es el de su miembro de
mayor tamao.
En el interior de una unin, 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 posicin de memoria.
Las uniones pueden referenciarse completas, usando su nombre, como
hacamos con las estructuras, y tambin se puede acceder a los elementos
en el interior de la unin usando el operador de seleccin (.), un punto.
Ejemplo de una unin:
#include <stdio.h>
#include <string.h>
/*Creamos una union*/
union ejemplo
{
char nombre[50];
char materia[50];
} palabra;
/*Creamos una estructura*/
struct comparacion

{
char nombre[50];
char materia[50];
} frase;
/*Ntese que la estructura y la unin tienen los mismos tipos de datos*/
int main()
{
/*Inicializamos*/
strcpy(palabra.nombre,"Pepe Luis");
strcpy(palabra.materia,"Software");

printf("\nFrases en Union: ");

/*Imprimimos nombre de union*/

printf("\n1- %s", palabra.nombre);

/*Imprimimos materia de union*/

printf("\n2- %s", palabra.materia);

/*Inicializamos*/
strcpy(frase.nombre,"Pepe Luis");
strcpy(frase.materia,"Software");

/* Debido a que las uniones usan el mismo espacio de memoria para

todos los miembros de la estructura, al imprimir se tiene
el mismo valor. El tamao del espacio de memoria es el de su miembro
mayor (50 bytes en este caso) por lo que todos sus
miembros tendrn que compartir ese espacio de memoria. El ultimo valor
agregado a la union es el que se tiene.*/

printf("\n\nFrases en Struct: ");

/*Imprimimos frase de struct*/

printf("\n1- %s", frase.nombre);

/*Imprimimos frase de struct*/

printf("\n2- %s", frase.materia);

/* En la estructura, se reservan 95 bytes de memoria para los dos

miembros, en este caso cada uno es independiente en
memoria, asi pues se puede inicializar cada uno o usar como un campo
independiente.*/
return 0;
}

Ejemplo 2:
#include <stdio.h>
union Number {
int x;
float y;};

int main()
{
Number value;
value.x=100;
printf("Imprimo el valor del miembro definido (x): %d\n",value.x);
value.y=10.5;
printf("Imprimo el valor del miembro definido (y): %d\n",value.y);
return 0;
}

Estructura lgica
Supongamos que en nuestro ordenador, int ocupa cuatro bytes, char un
byte y double ocho bytes. La forma en que se almacena la informacin en la
unin sera la siguiente:
Byte 0

Byte 1

Byte 2

Byte 3

Byte 4

Byte 5

Byte 6

A
B
C

Por el contrario, los mismos objetos almacenados en una estructura tendran

la siguiente disposicin:
Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte
0
1
2
3
4
5
6
7
8
9
10
A

Byte
11

Byte
12

Uso de Uniones
Se utiliza cuando se quiere que una misma variable pueda contener datos
de distinto tipo, o cuando se quiere utilizar una misma variable desde
distintos puntos de vista. Las uniones pueden presentarse dentro de
estructuras y arreglos y viceversa. Las operaciones que se pueden realizar
sobre uniones son las siguientes:
-

Asignar una unin a otra del mismo tipo.

Tomar la direccin de un tipo unin.
Acceder a los miembros de una unin utilizando el operador de
miembro de estructura (. selector directo) o el operador de
apuntador a estructura (& o -> apuntador indirecto).
No podemos comparar uniones debido a que no se sabe cul
miembro de cada una est activo.
Una unin puede inicializarse con un valor del mismo tipo que el
primer miembro de la unin.

Tambin pueden declararse ms objetos del tipo de la unin en cualquier

parte del programa, de la siguiente forma:
[union] <identifiador_de_unin> <variable>[,<variable>...];
La palabra clave unin es opcional en la declaracin de objetos en C++.
Aunque en C es obligatoria. El uso debe ser consistente con los valores
almacenados en cada caso, cuestin esta que queda bajo responsabilidad
del programador (esta es la razn principal para que se desaconseje su
uso .Si se lee un dato de tipo distinto al que se escribi, el resultado
obtenido es dependiente de la implementacin.
Algunas veces tenemos estructuras que son elementos del mismo tipo, por
ejemplo X, Y, y Z todos enteros. Pero en determinadas circunstancias, puede

Byte 7

convenirnos acceder a ellos como si fueran un array: Coor [0], Coor [1] y
Coor [2]. En este caso, la unin 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]

Uniones annimas
Uniones annimas son aquellas que no tienen etiqueta y tampoco se utilizan
para declarar un objeto nominado (con nombre). Tienen la forma general:
union { lista-de-miembros };
Sus miembros pueden ser accedidos directamente en el mbito de su
declaracin sin necesidad de usar ninguno de los operadores de
acceso x.y o p->y. Ejemplo:
#include <iostream.h>
void main () {
union { int i; double d; };
i = 25;
cout << "El valor de 'i' es: " << i << endl;
}
Salida:
El valor de 'i' es: 25
Las uniones annimas pueden ser globales, y anidadas o sin anidar.Ejemplo:
#include <iostream.h>
static union { int i; double d; } ;
void main () {
i = 15;
cout << "El valor de 'i' es: " << i << endl;

union { int i; double d; };

i = 25;
cout << "El valor de 'i' es: " << i << endl;
cout << "El valor de 'i' es: " << ::i << endl;
}
Salida:
El valor de 'i' es: 15
El valor de 'i' es: 25
El valor de 'i' es: 15
Las uniones annimas no pueden tener funciones miembro ni miembros
privados o protegidos (todos son pblicos). Si son globales deben ser
declaradas estticas, y sin son locales pueden ser estticas o automticas.
En otras palabras: las uniones annimas no pueden tener enlazado externo.
Ejemplo:
#include <iostream.h>
union { int i; double d; } ;
void main () {
cout << "El valor '?.i' es: " << i << endl;
}
Resultado de la compilacin:
Borland C++: Error E2020 pru1.c 2: Global anonymous union not static
Compilador GNU C++ 3.3.1 namespace-scope anonymous aggregates must
be static
-

Uniones annimas anidadas

La estructura, clase o unin exterior de una unin annima anidada debe

tener un nombre. C++ permite uniones annimas anidadas. Por ejemplo:
struct externa { // define estructura nominada externa
int x;
union {

// unin annima anidada

int y;
char c;
};
};
...
int main(void) {
struct externa ex1; // ex1 es una instancia de externa

return ex1.x + ex1.y;

}
-

Uniones de otros tipos

Las uniones pueden aparecer en matrices, estructuras y como miembros de

clases. A su vez, tambin pueden contener a dichos elementos.

Referencias

Uniones. 2016. Recuperado de: http://www.zator.com/Cpp/E4_7.htm

Programacin en C/Estructuras y Uniones. 2016. Recuperado de:
https://es.wikibooks.org/wiki/Programaci
%C3%B3n_en_C/Estructuras_y_Uniones
Curso C++, tipos de variable v: uniones. 2016. Recuperado de:
http://c.conclase.net/curso/?cap=016
UNIONES
en
C/C++.
2016.
Recuperado
de:
https://www.fing.edu.uy/tecnoinf/mvd/cursos/eda/material/teo/EDAteorico13.pdf