Summary  
Unions let you overlay multiple data types in the same memory location so that only one member’s value is stored at a time, with the union’s size determined by its largest member (plus any alignment padding).

General domain of usage  
Embedded systems programming for memory-efficient data representation

Una **unión** es un tipo de dato definido por el usuario en C, similar a una estructura. La principal diferencia es que **todos sus miembros comparten la misma ubicación de memoria**. En un momento dado, solo **un miembro** puede almacenar un valor.

Definición

Las uniones se usan con poca frecuencia, pero son útiles cuando se necesita una variable que pueda contener **diferentes tipos de datos en distintos momentos** y ahorrar memoria.

Las estructuras permiten combinar varias variables de diferentes tipos en una sola área de memoria.

Las uniones permiten combinar múltiples variables de diferentes tipos en una sola ubicación de memoria.

Cada variable tiene su propia dirección en memoria; todas las variables ocupan memoria de forma independiente.

Todas las variables comparten la misma área de memoria, lo que significa que usan la misma dirección.

Cada variable siempre contiene su propio valor independiente.

Solo una variable contiene datos válidos a la vez.

Se utiliza cuando se deben almacenar varios valores simultáneamente.

Principalmente se utiliza para almacenar uno de varios tipos de datos (no todos a la vez).

**Los datos se encuentran en la misma área de memoria** para todos los miembros de la unión.
Esto significa que todos los miembros de la unión comparten la misma dirección de memoria, y **el tamaño de la unión es igual al tamaño de su miembro más grande**.

El uso principal de una unión es la superposición de diferentes tipos de datos en una misma área de memoria, es decir, la representación de una sola área de memoria como diferentes tipos de datos.

Dado que en la unión los campos están en la misma celda de memoria, es posible procesar los mismos datos de diferentes maneras:


I2luY2x1ZGUgPHN0ZGlvLmg+CgovLyBkZWNsYXJpbmcgYSB1bmlvbiAKdW5pb24gRGF0YSB7CiAgICBpbnQgYTsKICAgIGNoYXIgYjsKfSBkYXRhOwoKaW50IG1haW4oKSB7CiAgICBkYXRhLmEgPSA3NzsgLy8gYXNzaWduaW5nIGEgdmFsdWUgdG8gdmFyaWFibGUgYQoKICAgIHByaW50ZigiVmFsdWUgb2YgZGF0YS5hOiAlZFxuIiwgZGF0YS5hKTsKICAgIHByaW50ZigiVmFsdWUgb2YgZGF0YS5iOiAlY1xuIiwgZGF0YS5iKTsKCiAgICByZXR1cm4gMDsKfQ==

En el ejemplo, las variables `data.a` y `data.b` comparten la misma memoria. Se asignó el valor 77 a `a`, pero se pueden interpretar los mismos bytes como un carácter en `b`.

### Alineación en las uniones

Al igual que las estructuras, las uniones también utilizan **alineación y relleno**. El compilador puede agregar bytes adicionales para que cada miembro comience en el límite de memoria adecuado.

I2luY2x1ZGUgPHN0ZGlvLmg+Cgp1bmlvbiBEYXRhIHsKICAgIGludCBhOyAvLyA0IGJ5dGVzCiAgICBkb3VibGUgYjsgLy8gOCBieXRlcwogICAgY2hhciBjWzIwXTsgLy8gMjAgYnl0ZXMKfTsKCmludCBtYWluKCkgewogICAgcHJpbnRmKCJTaXplIG9mIHVuaW9uIERhdGE6ICV6dSBieXRlc1xuIiwgc2l6ZW9mKHVuaW9uIERhdGEpKTsKCiAgICByZXR1cm4gMDsKfQ==

Una unión solo puede almacenar un valor a la vez, y su tamaño es igual al de su **miembro más grande**. En el ejemplo con `int a` (4 bytes), `double b` (8 bytes) y `char c[20]`, el tamaño mínimo de la unión es de 20 bytes. Sin embargo, el compilador puede agregar bytes adicionales para la **alineación**, de modo que `double` o `int` comiencen en el límite de memoria adecuado. Como resultado, `sizeof(union Data)` puede ser mayor que 20, por ejemplo, 24 bytes.


#define CATCH_CONFIG_MAIN
#include <catch2/catch.hpp>
#include <cstdio>
#include <cstring>

union Data {
    int a;
    char b;
};

void printAsciiValues(int values[], int n);

std::string capturePrintfOutput(int values[], int n) {
    // Создаем временный файл
    FILE* tmp = tmpfile();
    REQUIRE(tmp != nullptr);

    // Сохраняем старый stdout
    int old_stdout = dup(fileno(stdout));
    fflush(stdout);

    // Перенаправляем stdout в tmp
    dup2(fileno(tmp), fileno(stdout));

    // Вызываем функцию
    printAsciiValues(values, n);

    // Сбрасываем stdout
    fflush(stdout);
    dup2(old_stdout, fileno(stdout));
    close(old_stdout);

    // Читаем содержимое tmp
    fseek(tmp, 0, SEEK_SET);
    char buffer[1024] = {0};
    size_t nread = fread(buffer, 1, sizeof(buffer) - 1, tmp);
    fclose(tmp);

    return std::string(buffer, nread);
}

TEST_CASE("Uppercase ASCII letters", "[print]") {
    int values[] = {65, 66, 67, 68, 69}; // A–E
    std::string out = capturePrintfOutput(values, 5);

    REQUIRE(out.find("Value as int: 65, Value as char: A") != std::string::npos);
    REQUIRE(out.find("Value as int: 66, Value as char: B") != std::string::npos);
    REQUIRE(out.find("Value as int: 67, Value as char: C") != std::string::npos);
    REQUIRE(out.find("Value as int: 68, Value as char: D") != std::string::npos);
    REQUIRE(out.find("Value as int: 69, Value as char: E") != std::string::npos);
}

TEST_CASE("Lowercase ASCII letters", "[print]") {
    int values[] = {97, 98, 99}; // a b c
    std::string out = capturePrintfOutput(values, 3);

    REQUIRE(out.find("Value as int: 97, Value as char: a") != std::string::npos);
    REQUIRE(out.find("Value as int: 98, Value as char: b") != std::string::npos);
    REQUIRE(out.find("Value as int: 99, Value as char: c") != std::string::npos);
}

TEST_CASE("Digit ASCII characters", "[print]") {
    int values[] = {48, 49, 50}; // 0 1 2
    std::string out = capturePrintfOutput(values, 3);

    REQUIRE(out.find("Value as int: 48, Value as char: 0") != std::string::npos);
    REQUIRE(out.find("Value as int: 49, Value as char: 1") != std::string::npos);
    REQUIRE(out.find("Value as int: 50, Value as char: 2") != std::string::npos);
}

TEST_CASE("Symbol characters", "[print]") {
    int values[] = {33, 64, 35, 36}; // ! @ # $
    std::string out = capturePrintfOutput(values, 4);

    REQUIRE(out.find("Value as int: 33, Value as char: !") != std::string::npos);
    REQUIRE(out.find("Value as int: 64, Value as char: @") != std::string::npos);
    REQUIRE(out.find("Value as int: 35, Value as char: #") != std::string::npos);
    REQUIRE(out.find("Value as int: 36, Value as char: $") != std::string::npos);
}

TEST_CASE("Mixed ASCII values", "[print]") {
    int values[] = {65, 97, 48, 33}; // A, a, 0, !
    std::string out = capturePrintfOutput(values, 4);

    REQUIRE(out.find("Value as int: 65, Value as char: A") != std::string::npos);
    REQUIRE(out.find("Value as int: 97, Value as char: a") != std::string::npos);
    REQUIRE(out.find("Value as int: 48, Value as char: 0") != std::string::npos);
    REQUIRE(out.find("Value as int: 33, Value as char: !") != std::string::npos);
}

TEST_CASE("Repeated ASCII values", "[print]") {
    int values[] = {65, 65, 65}; // A A A
    std::string out = capturePrintfOutput(values, 3);

    int count = 0;
    size_t pos = out.find("Value as int: 65, Value as char: A");
    while (pos != std::string::npos) {
        count++;
        pos = out.find("Value as int: 65, Value as char: A", pos + 1);
    }

    REQUIRE(count == 3);
}

TEST_CASE("Empty input array", "[print]") {
    int values[] = {};
    std::string out = capturePrintfOutput(values, 0);

    REQUIRE(out.empty());
}

TEST_CASE("Edge ASCII values", "[print]") {
    int values[] = {0, 127}; // NUL and DEL
    std::string out = capturePrintfOutput(values, 2);

    REQUIRE(out.find("Value as int: 0, Value as char: ") != std::string::npos);
    REQUIRE(out.find("Value as int: 127, Value as char: ") != std::string::npos);
}

test.cpp

Adquiere una comprensión sólida de cómo funcionan las estructuras (structs) en C, desde definiciones básicas hasta conceptos avanzados de memoria. Explora cómo los punteros interactúan con datos estructurados, descubre formas eficientes de organizar información y gana confianza implementando estructuras de datos reales como listas enlazadas.

Explora los fundamentos de las estructuras, comprende por qué se utilizan y adquiere confianza al definir, crear y acceder a datos estructurados.

Descubre cómo los punteros interactúan con las estructuras, aprende por qué esta conexión es importante y domina técnicas clave como la asignación dinámica y el paso de estructuras a funciones

Adquisición de una comprensión sólida sobre cómo se almacenan las estructuras en la memoria, exploración del alineamiento y el relleno, y análisis de cómo las uniones ayudan a gestionar datos compartidos de manera eficiente.

Profundización en patrones avanzados de structs, incluyendo structs anidados y anónimos, exploración de formas prácticas de combinarlos con arreglos y familiarización con estructuras de datos comunes.

Desarrolla confianza al implementar una lista enlazada desde cero, explora su estructura y crea funciones esenciales para agregar, recorrer y gestionar los elementos de la lista.

Uniones

Alineación en las uniones

Example

Solución