Uniones y sus riesgos
Comparta memoria entre tipos
Uniones y sus riesgos es una lección gratuita de C++ Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C++ Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C++ Academy incluye 4 lecciones en total.
¿Qué es una unión?
Una union permite que varios miembros compartan la misma memoria. Solo un miembro es válido en cada momento y la unión ocupa tanto como su miembro más grande.
#include <iostream>
union Number {
int i;
float f;
};
int main() {
Number n;
n.i = 42;
std::cout << n.i << "\n";
}Tamaño de una unión
Como los miembros se solapan, sizeof una unión equivale al tamaño de su miembro más grande (más cualquier relleno de alineación), no a la suma de sus tamaños.
#include <iostream>
union Mix { char c; int i; double d; };
int main() {
std::cout << sizeof(Mix) << "\n"; // size of double (often 8)
}Escribir en uno y leer otro
Escribir en un miembro y leer otro diferente es el riesgo principal. Los bits se reinterpretan, lo que normalmente produce un comportamiento indefinido o resultados inesperados.
#include <iostream>
union Bits { int i; float f; };
int main() {
Bits b;
b.f = 1.0f;
std::cout << b.i << "\n"; // reads float bits as int
}Un solo miembro activo
El miembro en el que escribió por última vez es el único que puede leer de forma segura. Debe llevar usted mismo el control de qué miembro está «activo»; la unión no lo recuerda.
#include <iostream>
union Value { int i; double d; };
int main() {
Value v;
v.d = 3.14; // d is active
std::cout << v.d << "\n";
}El patrón de unión etiquetada
Para usar uniones de forma segura, combínelas con una etiqueta (un enum) que registre el miembro activo. Este es el antecesor manual de std::variant.
#include <iostream>
struct Tagged {
enum { Int, Double } tag;
union { int i; double d; };
};
int main() {
Tagged t; t.tag = Tagged::Int; t.i = 7;
if (t.tag == Tagged::Int) std::cout << t.i << "\n";
}Leer el miembro correcto
Compruebe siempre la etiqueta antes de leer. Leer el miembro equivocado produce valores basura.
#include <iostream>
struct Tagged {
enum { Int, Double } tag;
union { int i; double d; };
};
void print(const Tagged& t) {
if (t.tag == Tagged::Int) std::cout << "int " << t.i << "\n";
else std::cout << "double " << t.d << "\n";
}
int main() { Tagged t{Tagged::Double}; t.d = 2.5; print(t); }Miembros no triviales
Incluir en una unión un miembro con constructor o destructor, como std::string, requiere realizar manualmente la construcción y la destrucción. Esto es propenso a errores y constituye otra razón para preferir std::variant.
Uniones anónimas
Una unión anónima no tiene nombre; se accede directamente a sus miembros. Resulta práctica dentro de una estructura, pero se aplica la misma regla sobre el miembro activo.
#include <iostream>
struct Packet {
int kind;
union { int code; char letter; };
};
int main() {
Packet p; p.kind = 1; p.code = 99;
std::cout << p.code << "\n";
}Por qué las uniones son arriesgadas
Resumen de los peligros:
- No recuerdan qué miembro está activo.
- Leer un miembro inactivo es un comportamiento indefinido.
- Los tipos no triviales requieren gestionar manualmente su ciclo de vida.
Cuándo siguen siendo útiles las uniones
Las uniones siguen siendo útiles para trabajos de bajo nivel: reinterpretar bytes, ahorrar memoria en código embebido con recursos muy limitados o ajustarse a una disposición binaria fija. Para datos que representan «uno de varios tipos» en el uso cotidiano, prefiera la alternativa más segura.
Hacia std::variant
std::variant es una unión con seguridad de tipos que lleva el control del tipo activo y lanza una excepción si accede al tipo equivocado. El resto de este curso explora esta clase.
Comprobación rápida
Compruebe sus conocimientos sobre las uniones.
Resumen
Ha aprendido sobre las uniones:
- Todos los miembros comparten el mismo bloque de memoria.
- Solo es válido leer el miembro escrito en último lugar.
- Use una etiqueta (enum) para llevar el control del miembro activo.
- Prefiera
std::variantpara obtener seguridad en el C++ moderno.
Aprende C++ con un tutor de IA — gratis
Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.
- Cursos
- 51
- Lecciones
- 203
Preguntas frecuentes
¿La lección «Uniones y sus riesgos» es gratis?
Sí — el texto completo de «Uniones y sus riesgos» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C++ Academy, actualiza a CoddyKit PRO. El curso de C++ Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Uniones y sus riesgos»?
Comparta memoria entre tipos Practicas C++ Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar C++ Academy?
No se requiere experiencia previa. C++ Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.
¿Cuánto tiempo toma la lección «Uniones y sus riesgos»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de C++ Academy?
Sí. Cada lección de C++ Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- enum class con ámbito
- Uniones y sus riesgos
- std::variant
- std::visit