Sintaxis:
Una unión es un tipo definido por el usuario, que permite el almacenamiento de diversos tipos de datos dentro de una ubicación de memoria compartida. El uso de una unión sigue una sintaxis idéntica a la de una estructura.
La sintaxis fundamental es la siguiente:
Unión Nombre de la unión {
// Declaraciones de miembros
Miembro1 del tipo de datos1 ;
Tipo de datos2 miembro2 ;
// ...
} ;
Aquí, 'UnionName' sirve como identificador de la unión que proporciona un nombre único para hacer referencia a este tipo específico definido por el usuario. Los tipos de datos de los miembros del sindicato se indican como 'Tipo de datos1', 'Tipo de datos2', etc. Estos tipos de datos representan los distintos tipos de información que se pueden almacenar dentro de la unión. Cada miembro dentro del sindicato, designado por nombres como “miembro1”, “miembro2”, etc., representa un dato distinto.
Ahora entendemos la sintaxis básica. Usemos ahora algunos ejemplos para comprender mejor esto.
Ejemplo 1: uso básico de la unión
El primer ejemplo ilustra la utilización básica de uniones en C++, mostrando cómo permiten compartir espacio de memoria entre diferentes tipos de datos dentro de una única estructura.
Aquí hay un ejemplo:
#incluir
usando el espacio de nombres estándar ;
Unión matrizunión {
En t intArray [ 5 ] ;
flotar matriz flotante [ 5 ] ;
} ;
En t principal ( ) {
matrizUnión matrizUnión ;
para ( En t i = 0 ; i < 5 ; ++ i ) {
matrizUnión. intArray [ i ] = i * 2 ;
}
corte << 'Matriz interna:' ;
para ( En t i = 0 ; i < 5 ; ++ i ) {
corte << ' ' << matrizUnión. intArray [ i ] ;
}
corte << fin ;
para ( En t i = 0 ; i < 5 ; ++ i ) {
matrizUnión. matriz flotante [ i ] = i * 1.5f ;
}
corte << 'Matriz flotante:' ;
para ( En t i = 0 ; i < 5 ; ++ i ) {
corte << ' ' << matrizUnión. matriz flotante [ i ] ;
}
corte << fin ;
devolver 0 ;
}
En este fragmento de código C++, utilizamos una unión llamada 'MyUnion' que incorpora tres miembros de datos diferentes: un número entero (intValue), un número de punto flotante (floatValue) y un carácter (charValue). Sólo uno de estos miembros puede estar activo en un momento dado debido a la capacidad de un sindicato de compartir un espacio de memoria.
Dentro de la función 'principal', declaramos una instancia de la unión que es 'myUnion'. Primero, establecemos el valor del miembro entero en 42 y usamos 'cout' para imprimirlo. Posteriormente, asignamos el valor de punto flotante de 3,14 al miembro 'floatValue' y lo imprimimos. Por último, asignamos el carácter 'A' al miembro 'charValue' y lo imprimimos. Es esencial recordar que, dado que todos los miembros del sindicato comparten la misma ubicación de memoria, alterar a un miembro puede tener un impacto en los valores de otros miembros. El código concluye devolviendo 0, lo que significa una ejecución exitosa.
Ejemplo 2: Unión con Estructura
Una estructura es un tipo de datos en C++ que los usuarios pueden crear para combinar variables de varios tipos bajo un nombre unificado. Combinar una unión con una estructura puede resultar útil cuando queremos crear una estructura de datos que pueda contener diferentes tipos de datos y cada tipo esté asociado con un campo específico. Este emparejamiento permite el desarrollo de estructuras de datos complejas con diversas representaciones.
A continuación se muestra un ejemplo del uso de una unión dentro de una estructura en C++:
#incluirusando el espacio de nombres estándar ;
estructura Punto {
En t s1 ;
En t s2 ;
} ;
Unión Forma {
En t lados ;
flotar radio ;
Centro de puntos ;
} ;
En t principal ( ) {
forma forma ;
forma. lados = 5 ;
corte << 'Lados: ' << forma. lados << fin ;
forma. radio = 6.0f ;
corte << 'Radio:' << forma. radio << fin ;
forma. centro = { 10 , 20 } ;
corte << 'Centro: (' << forma. centro . s1 << ', ' << forma. centro . s2 << ')' << fin ;
devolver 0 ;
}
En este código, definimos un programa C++ que usa una unión y una estructura para representar diferentes aspectos de una forma geométrica. Primero, declaramos una estructura de 'Punto' que consta de dos miembros enteros, 's1' y 's2', que representan las coordenadas de un punto en un espacio 2D. Luego, definimos una 'unión' llamada 'Forma' que consta de tres miembros: un entero de 'lados', un punto flotante de 'radio' y una estructura de 'Punto' llamada 'centro'. Pasando a la función 'principal', creamos una instancia de un objeto 'Forma' llamado 'forma'. Luego demostramos la versatilidad del sindicato asignando valores a sus diferentes miembros. Inicialmente, establecemos el número de lados en 5 e imprimimos el resultado. A continuación, asignamos un radio de 6,0 a la forma y generamos el radio. Finalmente, asignamos un punto central con coordenadas (10, 20) a la forma e imprimimos las coordenadas del centro.
Ejemplo 3: Unión con Enum
En C++, las enumeraciones, comúnmente denominadas enumeraciones, sirven para definir una colección de constantes integrales con nombre. Combinar enumeraciones con uniones puede ser útil en escenarios donde queremos representar una variable que puede tomar diferentes tipos, cada uno asociado con un valor de enumeración específico.
He aquí un ejemplo:
#incluirusando el espacio de nombres estándar ;
enumeración Tipo de datos {
ENTERO ,
FLOTAR ,
CARBONIZARSE
} ;
Unión Valor de los datos {
En t valorint ;
flotar valor flotante ;
carbonizarse valorcarácter ;
} ;
estructura Datos {
tipo de tipo de datos ;
Valor de valor de datos ;
} ;
En t principal ( )
{
Datos datos1 , datos2 , datos3 ;
datos1. tipo = ENTERO ;
datos1. valor . valorint = 42 ;
datos2. tipo = FLOTAR ;
datos2. valor . valor flotante = 3.14f ;
datos3. tipo = CARBONIZARSE ;
datos3. valor . valorcarácter = 'A' ;
corte << 'Datos 1: ' << datos1. valor . valorint << fin ;
corte << 'Datos 2: ' << datos2. valor . valor flotante << fin ;
corte << 'Datos 3: ' << datos3. valor . valorcarácter << fin ;
devolver 0 ;
}
Para este ejemplo, tenemos un programa que utiliza enumeraciones, uniones y estructuras para crear una estructura de datos flexible que sea capaz de contener diferentes tipos de valores. La enumeración 'DataType' está definida para representar tres tipos de datos fundamentales: INTEGER, FLOAT y CHAR. La enumeración mejora la legibilidad y el mantenimiento del código al ofrecer un conjunto de constantes integrales con nombre.
Luego, hacemos una unión llamada “DataValue” con tres miembros: “charValue” de tipo char, “floatValue” de tipo float e “intValue” de tipo int. Con una unión, estos miembros comparten una ubicación de memoria común que permite a la unión acomodar indistintamente los valores de distintos tipos. Luego se crea la estructura 'Datos', que consta de dos miembros: un enumerador 'Tipo de datos' llamado 'tipo' y una unión 'Valor de datos' llamada 'valor'. Esta estructura nos permite asociar un tipo de datos con su valor correspondiente, proporcionando una representación estructurada.
En la función 'principal', creamos instancias de tres instancias de la estructura 'Datos': 'datos1', 'datos2' y 'datos3'. Asignamos los valores a estas instancias especificando el tipo de datos y estableciendo el valor apropiado dentro de la unión. Por ejemplo, a “datos1” se le asigna un tipo INTEGER con un valor de 42. Finalmente, usamos las declaraciones “cout” para imprimir los valores que se almacenan en cada instancia de “Datos”. El programa genera el valor entero de 'datos1', el valor de punto flotante de 'datos2' y el valor de carácter de 'datos3'.
Este ejemplo ilustra cómo se puede emplear la combinación de enumeraciones, uniones y estructuras para crear una representación de datos versátil y con seguridad de tipos en C++.
Conclusión
Las uniones de C++ proporcionan un mecanismo potente y flexible para gestionar los diversos tipos de datos dentro de un único espacio de memoria. Los casos que se ilustran en este artículo resaltan la adaptabilidad y eficacia de los sindicatos para abordar una variedad de escenarios. Desde los usos fundamentales que demuestran la intercambiabilidad de tipos de datos hasta aplicaciones más complejas que involucran estructuras y enumeraciones, estos ejemplos subrayan la eficiencia y adaptabilidad que las uniones aportan a la programación en C++.