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

En **union** är en användardefinierad datatyp i C, liknande en struktur. Den största skillnaden är att **alla dess medlemmar delar samma minnesplats**. Vid varje givet tillfälle kan endast **en medlem** lagra ett värde.

Definition

Unioner används sällan, men de är användbara när du vill ha en variabel som kan innehålla **olika datatyper vid olika tillfällen** och samtidigt spara minne.

Structures allow you to combine several variables of different types in one memory area.

Unions allow you to combine multiple variables of different types into one memory location.

Each variable has its own address in memory; all variables occupy memory independently.

All variables share the same memory area, meaning they use the same address.

Each variable always contains its own independent value.

Only one variable contains valid data at a time.

Used when multiple values must be stored simultaneously.

Mainly used to store one of many types of data (not all at once).

**Data lagras i samma minnesområde** för alla medlemmar i unionen.
Detta innebär att alla medlemmar i unionen delar samma minnesadress, och **storleken på unionen är lika med storleken på dess största medlem**.

Huvudanvändningen av union är att tillåta olika datatyper att använda ett gemensamt minnesområde, det vill säga att representera ett minnesområde som olika datatyper.

Eftersom fälten i en union delar samma minnescell kan vi bearbeta samma data på olika sätt:


I2luY2x1ZGUgPHN0ZGlvLmg+CgovLyBkZWNsYXJpbmcgYSB1bmlvbiAKdW5pb24gRGF0YSB7CiAgICBpbnQgYTsKICAgIGNoYXIgYjsKfSBkYXRhOwoKaW50IG1haW4oKSB7CiAgICBkYXRhLmEgPSA3NzsgLy8gYXNzaWduaW5nIGEgdmFsdWUgdG8gdmFyaWFibGUgYQoKICAgIHByaW50ZigiVmFsdWUgb2YgZGF0YS5hOiAlZFxuIiwgZGF0YS5hKTsKICAgIHByaW50ZigiVmFsdWUgb2YgZGF0YS5iOiAlY1xuIiwgZGF0YS5iKTsKCiAgICByZXR1cm4gMDsKfQ==

I exemplet delar variablerna `data.a` och `data.b` samma minne. Vi tilldelade värdet 77 till `a`, men vi kan tolka samma byte som ett tecken i `b`.

### Justering i unioner

Precis som strukturer använder unioner också **justering och utfyllnad**. Kompilatorn kan lägga till extra byte så att varje medlem börjar vid rätt minnesgräns.

I2luY2x1ZGUgPHN0ZGlvLmg+Cgp1bmlvbiBEYXRhIHsKICAgIGludCBhOyAvLyA0IGJ5dGVzCiAgICBkb3VibGUgYjsgLy8gOCBieXRlcwogICAgY2hhciBjWzIwXTsgLy8gMjAgYnl0ZXMKfTsKCmludCBtYWluKCkgewogICAgcHJpbnRmKCJTaXplIG9mIHVuaW9uIERhdGE6ICV6dSBieXRlc1xuIiwgc2l6ZW9mKHVuaW9uIERhdGEpKTsKCiAgICByZXR1cm4gMDsKfQ==

En union kan endast lagra ett värde åt gången, och dess storlek är lika med storleken på dess **största medlem**. I exemplet med `int a` (4 byte), `double b` (8 byte) och `char c[20]` är minsta storleken på unionen 20 byte. Kompilatorn kan dock lägga till extra byte för **justering**, så att `double` eller `int` börjar vid rätt minnesgräns. Som ett resultat kan `sizeof(union Data)` vara större än 20, till exempel 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

Få en gedigen förståelse för hur strukturer fungerar i C, från grundläggande definitioner till avancerade minneskoncept. Utforska hur pekare interagerar med strukturerad data, upptäck effektiva sätt att organisera information och bygg självförtroende genom att implementera verkliga datastrukturer såsom länkade listor.

Utforska grunderna i structs, förstå varför de används och bygg upp självförtroende i att definiera, skapa och komma åt strukturerad data.

Upptäck hur pekare interagerar med strukturer, lär dig varför denna koppling är viktig och behärska viktiga tekniker såsom dynamisk allokering och att skicka strukturer till funktioner

Få en gedigen förståelse för hur structs lagras i minnet, utforska inriktning och utfyllnad, samt lär dig hur unions hjälper till att hantera delad data effektivt.

Fördjupa dig i avancerade struct-mönster, inklusive nästlade och anonyma structs, utforska praktiska sätt att kombinera dem med arrayer och bli bekant med vanliga datastrukturer.

Bygg självförtroende genom att implementera en länkad lista från grunden, utforska dess struktur och skapa grundläggande funktioner för att lägga till, traversera och hantera listelement.

Unioner

Justering i unioner

Exempel

Lösning