Una unión es un tipo de clase especial en C++ que permite almacenar diferentes tipos de datos en una ubicación de memoria compartida. A diferencia de las estructuras, donde cada parte de una estructura normalmente tiene su propia memoria, las uniones permiten que diferentes fragmentos de datos utilicen la misma ubicación de memoria. Esta característica hace que las uniones sean particularmente útiles cuando la eficiencia de la memoria es una prioridad y solo es necesario acceder a un miembro a la vez. En este artículo, profundizaremos en el concepto de uniones en C++ y exploraremos varios ejemplos para demostrar su utilidad en varios escenarios.
sintaxis:
Una unión es un tipo definido por el usuario que permite almacenar diferentes tipos de datos en una ubicación de memoria compartida. El uso de uniones sigue la misma sintaxis que las estructuras.
La sintaxis básica es la siguiente:
// declaración de miembro
Tipo de datos 1 miembro 1;
Tipo de datos 2 miembro 2;
//…
};
Aquí, se utiliza «UnionName» 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 expresan como «DataType1», «DataType2», etc. Estos tipos de datos representan los diversos tipos de información que se pueden almacenar dentro de una unión. Cada miembro del sindicato (especificado por nombres como «miembro1», «miembro2», etc.) representa datos diferentes.
Ahora entendemos la sintaxis básica. Ahora entendamos esto mejor usando algunos ejemplos.
Ejemplo 1: uso básico de Union
El primer ejemplo ilustra el uso básico de uniones en C++, mostrando cómo comparten espacio de memoria entre diferentes tipos de datos dentro de una única estructura.
Aquí hay un ejemplo:
Usar espacio de nombres estándar;
Alianza unión de matriz {
entero matriz de enteros[5];
flotar matriz de números de coma flotante[5];
};
entero principal() {
Unión de arreglos Unión de arreglos;
para (entero I = ; I 5; ++I) {
Alianza de matrices.matriz de enteros[i] = I * 2;
}
kut «Matriz de números enteros:»;
para (entero I = ; I 5; ++I) {
kut «» Alianza de matrices.matriz de enteros[i];
}
kut endel;
para (entero I = ; I 5; ++I) {
Alianza de matrices.matriz de números de coma flotante[i] = I * 1.5f;
}
kut «Matriz de punto flotante:»;
para (entero I = ; I 5; ++I) {
kut «» Alianza de matrices.matriz de números de coma flotante[i];
}
kut endel;
devolver ;
}
En este fragmento de código C++, utilizamos una unión llamada «MyUnion», que contiene tres miembros de datos diferentes: entero (intValue), número de coma flotante (floatValue) y carácter (charValue). Debido a la capacidad de la federación para compartir espacio de memoria, sólo un miembro puede estar activo en un momento dado.
En la función «principal», declaramos una instancia de unión «myUnion». Primero, establecemos el valor del miembro entero en 42 y lo imprimimos usando «cout». Luego asignamos el valor de coma flotante 3.14 al miembro «floatValue» y lo imprimimos. Finalmente, asignamos el carácter «A» al miembro «charValue» y lo imprimimos. Es importante recordar que, dado que todos los miembros del sindicato comparten la misma ubicación de memoria, cambiar a un miembro puede tener un impacto en los valores de otros miembros. El código del programa devuelve 0 al final, lo que indica una ejecución exitosa.
Ejemplo 2: Uniones y Estructuras
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 uniones con estructuras es útil cuando queremos crear una estructura de datos que pueda contener diferentes tipos de datos y cada tipo esté asociado a un campo específico. Este emparejamiento permite el desarrollo de estructuras de datos complejas con diferentes representaciones.
A continuación se muestra un ejemplo del uso de una unión en una estructura C++:
Usar espacio de nombres estándar;
Estructura Vista {
entero s1;
entero s2;
};
Alianza forma {
entero lado;
flotar radio;
centro de punto;
};
entero principal() {
forma forma;
forma.lado = 5;
kut «ambos lados:» forma.lado endel;
forma.radio = 6.0f;
kut «Radio:» forma.radio endel;
forma.centro = {10, 20};
kut «centro: (« forma.centro.s1 «,» forma.centro.s2 «)» endel;
devolver ;
}
En este código, definimos un programa C++ que utiliza uniones y estructuras para representar diferentes aspectos de la geometría. 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 bidimensional. 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». Al ir a la función «principal», creamos una instancia de un objeto «Forma» llamado «forma». Luego demostramos la versatilidad de la alianza asignando valores a los diferentes miembros. Inicialmente, establecemos el número de lados en 5 e imprimimos los resultados. A continuación, le damos a la forma un radio de 6,0 y generamos el radio. Finalmente, asignamos a la forma un punto central con coordenadas (10, 20) e imprimimos las coordenadas del centro.
Ejemplo 3: Unión con Enum
En C++, una enumeración (a menudo llamada enumeración) se utiliza para definir una colección de constantes enteras con nombre. Combinar una enumeración con una unión es útil cuando queremos representar una variable que puede tomar diferentes tipos, con cada tipo asociado con un valor de enumeración específico.
Aquí hay un ejemplo:
Usar espacio de nombres estándar;
enumerar Tipo de datos {
entero,
flotar,
personaje
};
Alianza valor de los datos {
entero valor entero;
flotar Valor de punto flotante;
personaje valor del caracter;
};
Estructura datos {
tipo de tipo de datos;
valor del valor de los datos;
};
entero principal()
{
datos datos 1, Datos 2, Datos 3;
Datos 1.tipo = entero;
Datos 1.valor.valor entero = 42;
Datos 2.tipo = flotar;
Datos 2.valor.Valor de punto flotante = 3.14f;
Datos 3.tipo = personaje;
Datos 3.valor.valor del caracter = 'A';
kut «Datos 1:» Datos 1.valor.valor entero endel;
kut «Datos 2:» Datos 2.valor.Valor de punto flotante endel;
kut «Datos 3:» Datos 3.valor.valor del caracter endel;
devolver ;
}
Para este ejemplo, tenemos un programa que utiliza enumeraciones, uniones y estructuras para crear estructuras de datos flexibles que pueden contener diferentes tipos de valores. La enumeración «DataType» se define para representar tres tipos de datos básicos: INTEGER, FLOAT y CHAR. Las enumeraciones mejoran la legibilidad y el mantenimiento del código al proporcionar un conjunto de constantes enteras con nombre.
Luego, creamos una unión llamada «DataValue», que contiene tres miembros: «charValue» de tipo char, «floatValue» de tipo float e «intValue» de tipo int. A través de una unión, estos miembros comparten una ubicación de memoria común, lo que permite que la unión contenga valores de diferentes tipos de manera intercambiable. Luego cree una estructura de «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 tipos de materiales con sus valores correspondientes, proporcionando así una representación estructurada.
En la función «principal», creamos instancias de tres instancias de la estructura «Datos»: «datos1», «datos2» y «datos3». Asignamos 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. 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 muestra cómo combinar enumeraciones, uniones y estructuras para crear una representación de datos común y con seguridad de tipos en C++.
en conclusión
Las uniones de C++ proporcionan un mecanismo potente y flexible para gestionar diferentes tipos de datos dentro de un único espacio de memoria. Los ejemplos ilustrados en este artículo resaltan la adaptabilidad y eficacia de los sindicatos para resolver una variedad de situaciones. Desde usos básicos que demuestran la intercambiabilidad de tipos de datos hasta aplicaciones más complejas que involucran estructuras y enumeraciones, estos ejemplos resaltan la eficiencia y adaptabilidad que las uniones aportan a la programación en C++.
