| |
Hemos visto que las estructuras toman una parte de la memoria y se la reparten entre sus miembros. Cada miembro tiene reservado un espacio para él solo. El tamaño total que ocupa una estructura en memoria es la suma del tamaño que ocupa cada uno de sus miembros.
Las uniones tienen un aspecto similar en cuanto a cómo se definen, pero tienen una diferencia fundamental con respecto a las estructuras: los miembros comparten el mismo trozo de memoria. El espacio que ocupa en memoria una unión es el espacio que ocupa el campo más grande. Para entenderlo mejor vamos a ver un ejemplo:
Primero vamos a ver cómo se define una unión:
union nombre_de_la_unión
{
campos de la unión
};
NOTA: No se debe olvidar el ';' después de cerrar llaves '}'.
Y aquí va el ejemplo:
union _persona
{
char nombre[10];
char inicial;
};
Creamos una unión y sus elementos son un nombre de 10 bytes (nombre[10]) y la inicial (1 byte). Como hemos dicho la unión ocupa el espacio de su elemento más grande, en este caso nombre. Por lo tanto la unión ocupa 10 bytes. Las variables nombre e inicial comparten el mismo sitio de la memoria. Si accedemos a nombre estaremos accediendo a los primeros 10 bytes de la unión (es decir, a toda la unión), si accedemos a inicial lo que tendremos es el primer byte de la unión.
#include <stdio.h>
union _persona
{
char nombre[10];
char inicial;
} pers;
int main()
{
printf("Escribe tu nombre: ");
gets(pers.nombre);
printf("\nTu nombre es: %s\n", pers.nombre);
printf("Tu inicial es: %c\n", pers.inicial);
}
Ejecutando el programa:
Escribe tu nombre: Gorka Tu nombre es: Gorka Tu inicial es: G
Para comprender mejor eso de que comparten el mismo espacio en memoria vamos a ampliar el ejemplo. Si añadimos unas líneas al final que modifiquen sólo la inicial e imprima el nuevo nombre:
#include <stdio.h>
union _persona
{
char nombre[10];
char inicial;
} pers;
int main()
{
printf("Escribe tu nombre: ");
gets(pers.nombre);
printf("\nTu nombre es: %s\n", pers.nombre);
printf("Tu inicial es: %c\n", pers.inicial);
/* Cambiamos la inicial */
pers.inicial='Z';
printf("\nAhora tu nombre es: %s\n", pers.nombre);
printf("y tu inicial es: %c\n", pers.inicial);
}
Tendremos el siguiente resultado:
Escribe tu nombre: gorka Tu nombre es: gorka Tu inicial es: g Ahora tu nombre es: Zorka y tu inicial es: Z
Aquí queda claro que al cambiar el valor de la inicial estamos cambiando también el nombre porque la inicial y la primera letra del nombre son la misma posición de la memoria.
Con las uniones podemos usar punteros de manera similar a lo que vimos en el capítulo de las estructuras.
En el capítulo de la constantes (cap. 4) vimos que se podía dar nombre a las constantes con #define. Utilizando esta técnica podríamos hacer un programa en que definiríamos las constantes primero...quinto.
#include <stdio.h>
#define primero 1
#define segundo 2
#define tercero 3
#define cuarto 4
#define quinto 5
int main()
{
int posicion;
posicion=segundo;
printf("posicion = %i\n", posicion);
}
Sin embargo existe otra forma de declarar estas constantes y es con las enumeraciones. Las enumeraciones se crean con enum:
enum nombre_de_la_enumeración
{
nombres de las constantes
};
Por ejemplo:
enum { primero, segundo, tercero, cuarto, quinto };
De esta forma hemos definido las constantes primero, segundo,... quinto. Si no especificamos nada la primera constante (primero) toma el valor 0, la segunda (segunda) vale 1, la tercera 2,... Podemos cambiar estos valores predeterminados por los valores que deseemos:
enum { primero=1, segundo, tercero, cuarto, quinto };
Ahora primero vale 1, segundo vale 2, tercero vale 3,... Cada constante toma el valor de la anterior más uno. Si por ejemplo hacemos:
enum { primero=1, segundo, quinto=5, sexto, septimo };
Tendremos: primero=1, segundo=2, quinto=5, sexto=6, septimo=7.
Con esta nueva técnica podemos volver a escribir el ejemplo de antes:
#include <stdio.h>
enum { primero=1, segundo, tercero, cuarto, quinto } posicion;
int main()
{
posicion=segundo;
printf("posicion = %i\n", posicion);
}
Las constantes definidas con enum sólo pueden tomar valores enteros (pueden ser negativos). Son equivalentes a las variables de tipo int.
Un error habitual suele ser pensar que es posible imprimir el nombre de la constante:
#include <stdio.h>
enum { primero=1, segundo, tercero, cuarto, quinto } posicion;
int main()
{
printf("posicion = %s\n", segundo);
}
Es habitual pensar que con este ejemplo tendremos como resultado: posicion = segundo. Pero no es así, en todo caso tendremos: posicion = (null)
Debemos pensar en las enumeraciones como una forma de hacer el programa más comprensible para los humanos, en nuestro ejemplo el ordenador donde vea segundo pondrá un 2 en su lugar.
Ejercicio :
Solución:
© Gorka Urrutia