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

Een **union** is een door de gebruiker gedefinieerd gegevenstype in C, vergelijkbaar met een structuur. Het belangrijkste verschil is dat **alle leden dezelfde geheugenlocatie delen**. Op elk moment kan slechts **één lid** een waarde opslaan.

Definitie

Unions worden zelden gebruikt, maar zijn nuttig wanneer je een variabele wilt die **verschillende typen gegevens op verschillende momenten** kan bevatten en tegelijkertijd geheugen bespaart.

Structuren maken het mogelijk om meerdere variabelen van verschillende typen te combineren in één geheugenruimte.

Unions maken het mogelijk om meerdere variabelen van verschillende typen te combineren in één geheugenlocatie.

Elke variabele heeft een eigen adres in het geheugen; alle variabelen gebruiken onafhankelijk geheugen.

Alle variabelen delen hetzelfde geheugen, wat betekent dat ze hetzelfde adres gebruiken.

Elke variabele bevat altijd een eigen, onafhankelijke waarde.

Slechts één variabele bevat op een bepaald moment geldige data.

Gebruikt wanneer meerdere waarden gelijktijdig moeten worden opgeslagen.

Voornamelijk gebruikt om één van meerdere gegevenstypen op te slaan (niet allemaal tegelijk).

**De gegevens bevinden zich in hetzelfde geheugengebied** voor alle leden van de union.
Dit betekent dat alle leden van de union hetzelfde geheugenadres delen, en **de grootte van de union is gelijk aan de grootte van het grootste lid**.

Het belangrijkste gebruik van een union is het opleggen van verschillende typen gegevens op één gemeenschappelijk geheugengebied, oftewel de representatie van één geheugengebied als verschillende datatypes.

Omdat in de union de velden zich in dezelfde geheugenruimte bevinden, kunnen we dezelfde gegevens op verschillende manieren verwerken:


I2luY2x1ZGUgPHN0ZGlvLmg+CgovLyBkZWNsYXJpbmcgYSB1bmlvbiAKdW5pb24gRGF0YSB7CiAgICBpbnQgYTsKICAgIGNoYXIgYjsKfSBkYXRhOwoKaW50IG1haW4oKSB7CiAgICBkYXRhLmEgPSA3NzsgLy8gYXNzaWduaW5nIGEgdmFsdWUgdG8gdmFyaWFibGUgYQoKICAgIHByaW50ZigiVmFsdWUgb2YgZGF0YS5hOiAlZFxuIiwgZGF0YS5hKTsKICAgIHByaW50ZigiVmFsdWUgb2YgZGF0YS5iOiAlY1xuIiwgZGF0YS5iKTsKCiAgICByZXR1cm4gMDsKfQ==

In het voorbeeld delen de variabelen `data.a` en `data.b` hetzelfde geheugen. We hebben de waarde 77 toegekend aan `a`, maar we kunnen dezelfde bytes interpreteren als een teken in `b`.

### Uitlijning in unions

Net als structuren gebruiken unions ook **uitlijning en opvulling**. De compiler kan extra bytes toevoegen zodat elk lid op de juiste geheugenboundary begint.

I2luY2x1ZGUgPHN0ZGlvLmg+Cgp1bmlvbiBEYXRhIHsKICAgIGludCBhOyAvLyA0IGJ5dGVzCiAgICBkb3VibGUgYjsgLy8gOCBieXRlcwogICAgY2hhciBjWzIwXTsgLy8gMjAgYnl0ZXMKfTsKCmludCBtYWluKCkgewogICAgcHJpbnRmKCJTaXplIG9mIHVuaW9uIERhdGE6ICV6dSBieXRlc1xuIiwgc2l6ZW9mKHVuaW9uIERhdGEpKTsKCiAgICByZXR1cm4gMDsKfQ==

Een union kan slechts één waarde tegelijk opslaan en de grootte is gelijk aan de grootte van het **grootste lid**. In het voorbeeld met `int a` (4 bytes), `double b` (8 bytes) en `char c[20]`, is de minimale grootte van de union 20 bytes. De compiler kan echter extra bytes toevoegen voor **uitlijning**, zodat `double` of `int` op de juiste geheugenboundary beginnen. Hierdoor kan `sizeof(union Data)` groter zijn dan 20, bijvoorbeeld 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

Verkrijg een grondig begrip van hoe structs werken in C, van basisdefinities tot geavanceerde geheugenconcepten. Ontdek hoe pointers samenwerken met gestructureerde data, ontdek efficiënte manieren om informatie te organiseren en bouw vertrouwen op door echte datastructuren zoals gekoppelde lijsten te implementeren.

Verken de basisprincipes van structs, begrijp waarom ze worden gebruikt en ontwikkel vertrouwen in het definiëren, creëren en benaderen van gestructureerde gegevens.

Ontdek hoe pointers samenwerken met structs, leer waarom deze verbinding belangrijk is en beheers belangrijke technieken zoals dynamische toewijzing en het doorgeven van structs aan functies.

Verkrijg een grondig begrip van hoe structs in het geheugen worden opgeslagen, verken uitlijning en opvulling, en leer hoe unions helpen bij het efficiënt beheren van gedeelde data.

Verdiep u in geavanceerde struct-patronen, waaronder geneste en anonieme structs, verken praktische manieren om ze te combineren met arrays en maak kennis met veelvoorkomende datastructuren.

Bouw vertrouwen op door een gekoppelde lijst vanaf nul te implementeren, verken de structuur ervan en maak essentiële functies voor het toevoegen, doorlopen en beheren van lijst-elementen.

Unies

Uitlijning in unions

Voorbeeld

Oplossing