Curso de C++ (Página 18)

pagina017b Principal pagina019

CAPITULO 18 Estructuras II: 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 [<tipo unión>] {

[<tipo> <nombre de variable>[, <nombre variable>, ...]] ;

} [<variable de unión>[,<variable union>...]] ;

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

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

Sin embargo, 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 las variables. La particularidad es que cada elemento comenzará 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 variables del tipo de la unión en cualquier parte del programa, de la siguiente forma:

[union] <nombre de la unión> <variable de unión>[,<variable unión>...];

La palabra "union" es opcional en la declaración de variables.

Ejemplo:

#include <iostream.h>
 
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(unEjemplo::A) << endl; 
   cout << sizeof(unEjemplo::B) << endl; 
   cout << sizeof(unEjemplo::C) << endl; 
   return 0; 
} 

Suponiendo que int ocupa dos bytes, char un byte y double 4 bytes, la forma en que se almacena la información en la unión del ejemplo es la siguiente:

[BYTE1][BYTE2][BYTE3][BYTE4]
[<----A----->]
[<-B->]
[<-----------C------------>]

Por el contrario, la misma disposición de variables en una estructura tendría la siguiente disposición:

[BYTE1][BYTE2][BYTE3][BYTE4][BYTE5][BYTE6][BYTE7]
[<----A----->][<-B->][<-----------C------------>]

Unas notas sobre el ejemplo:

Otro ejemplo, é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 ser útil:

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

Podemos referirnos a la coordenada Y de estas dos formas:

Punto.N.Y
Punto.Coor[1]

Estructuras anónimas:

Una estructura anónima es la que carece de indentificador de tipo de estructura y de declaración 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] 

El método usado para declarar la estructura dentro de la unión es la forma anónima, como verás no tiene identificador de tipo de estructura ni de variables. El único lugar donde es legal el uso de estructuras anónimas es en el interior de estructuras y uniones.


pagina017b Principal pagina019