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 **union** è un tipo di dato definito dall'utente in C, simile a una struttura. La principale differenza è che **tutti i suoi membri condividono la stessa posizione di memoria**. In qualsiasi momento, solo **un membro** può contenere un valore.

Definizione

Le union sono usate raramente, ma sono utili quando si desidera una variabile che possa contenere **tipi di dati diversi in momenti diversi** risparmiando memoria.

Le strutture permettono di combinare diverse variabili di tipi differenti in un'unica area di memoria.

Le union permettono di combinare più variabili di tipi differenti in un'unica posizione di memoria.

Ogni variabile ha il proprio indirizzo in memoria; tutte le variabili occupano memoria in modo indipendente.

Tutte le variabili condividono la stessa area di memoria, cioè usano lo stesso indirizzo.

Ogni variabile contiene sempre il proprio valore indipendente.

Solo una variabile contiene dati validi alla volta.

Utilizzato quando è necessario memorizzare più valori contemporaneamente.

Utilizzato principalmente per memorizzare uno tra molti tipi di dati (non tutti insieme).

**I dati si trovano nella stessa area di memoria** per tutti i membri dell'unione. 
Questo significa che tutti i membri dell'unione condividono lo stesso indirizzo di memoria e **la dimensione dell'unione è pari a quella del suo membro più grande**.

L'uso principale di una union è la sovrapposizione di diversi tipi di dati su una stessa area di memoria, ovvero la rappresentazione di una singola area di memoria come tipi di dati differenti.

Poiché in una union i campi occupano la stessa cella di memoria, è possibile elaborare gli stessi dati in modi diversi:


I2luY2x1ZGUgPHN0ZGlvLmg+CgovLyBkZWNsYXJpbmcgYSB1bmlvbiAKdW5pb24gRGF0YSB7CiAgICBpbnQgYTsKICAgIGNoYXIgYjsKfSBkYXRhOwoKaW50IG1haW4oKSB7CiAgICBkYXRhLmEgPSA3NzsgLy8gYXNzaWduaW5nIGEgdmFsdWUgdG8gdmFyaWFibGUgYQoKICAgIHByaW50ZigiVmFsdWUgb2YgZGF0YS5hOiAlZFxuIiwgZGF0YS5hKTsKICAgIHByaW50ZigiVmFsdWUgb2YgZGF0YS5iOiAlY1xuIiwgZGF0YS5iKTsKCiAgICByZXR1cm4gMDsKfQ==

Nell'esempio, le variabili `data.a` e `data.b` condividono la stessa memoria. Abbiamo assegnato il valore 77 a `a`, ma possiamo interpretare gli stessi byte come un carattere in `b`.

### Allineamento nelle union

Come le struct, anche le union utilizzano **allineamento e padding**. Il compilatore può aggiungere byte extra affinché ogni membro inizi al corretto confine di memoria.

I2luY2x1ZGUgPHN0ZGlvLmg+Cgp1bmlvbiBEYXRhIHsKICAgIGludCBhOyAvLyA0IGJ5dGVzCiAgICBkb3VibGUgYjsgLy8gOCBieXRlcwogICAgY2hhciBjWzIwXTsgLy8gMjAgYnl0ZXMKfTsKCmludCBtYWluKCkgewogICAgcHJpbnRmKCJTaXplIG9mIHVuaW9uIERhdGE6ICV6dSBieXRlc1xuIiwgc2l6ZW9mKHVuaW9uIERhdGEpKTsKCiAgICByZXR1cm4gMDsKfQ==

Una union può memorizzare solo un valore alla volta e la sua dimensione è pari a quella del suo **membro più grande**. Nell'esempio con `int a` (4 byte), `double b` (8 byte) e `char c[20]`, la dimensione minima della union è 20 byte. Tuttavia, il compilatore può aggiungere byte extra per l'**allineamento**, affinché `double` o `int` inizino al corretto confine di memoria. Di conseguenza, `sizeof(union Data)` può essere maggiore di 20, ad esempio 24 byte.


#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

Acquisire una solida comprensione del funzionamento delle struct in C, dalle definizioni di base ai concetti avanzati di memoria. Esplorare come i puntatori interagiscono con i dati strutturati, scoprire modi efficienti per organizzare le informazioni e acquisire sicurezza implementando strutture dati reali come le liste collegate.

Esplora i fondamenti delle struct, comprendi perché vengono utilizzate e acquisisci sicurezza nella definizione, creazione e accesso ai dati strutturati.

Scopri come i puntatori interagiscono con le struct, comprendi l'importanza di questa connessione e padroneggia tecniche fondamentali come l'allocazione dinamica e il passaggio di struct alle funzioni

Acquisizione di una solida comprensione di come le struct vengono memorizzate in memoria, esplorazione dell'allineamento e del padding, e analisi di come le union aiutano a gestire efficientemente i dati condivisi.

Approfondimento sui modelli avanzati di struct, inclusi struct annidati e anonimi, esplorazione di modalità pratiche per combinarli con array e familiarizzazione con le strutture dati comuni.

Acquisire sicurezza implementando una lista collegata da zero, esplorare la sua struttura e creare funzioni essenziali per l'aggiunta, la traversata e la gestione degli elementi della lista.

Unioni

Allineamento nelle union

Example

Soluzione