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

**Union** on C-kielessä käyttäjän määrittelemä tietotyyppi, joka muistuttaa rakennetta (structure). Pääasiallinen ero on, että **kaikki jäsenet jakavat saman muistipaikan**. Kussakin hetkessä vain **yksi jäsen** voi sisältää arvon.

Määritelmä

Unioneita käytetään harvoin, mutta ne ovat hyödyllisiä, kun halutaan muuttuja, joka voi sisältää **eri tyyppistä dataa eri aikoina** ja samalla säästää muistia.

Rakenteet mahdollistavat useiden erilaisten muuttujien yhdistämisen yhteen muistialueeseen.

Unionit mahdollistavat useiden erilaisten muuttujien yhdistämisen yhteen muistipaikkaan.

Jokaisella muuttujalla on oma muistiosoitteensa; kaikki muuttujat vievät muistia itsenäisesti.

Kaikki muuttujat jakavat saman muistialueen, eli ne käyttävät samaa osoitetta.

Jokaisella muuttujalla on aina oma itsenäinen arvonsa.

Vain yhdellä muuttujalla on kerrallaan kelvollinen arvo.

Käytetään, kun useita arvoja täytyy tallentaa samanaikaisesti.

Käytetään pääasiassa, kun halutaan tallentaa yksi monista tietotyypeistä (ei kaikkia yhtä aikaa).

**Data sijaitsee samassa muistialueessa** kaikille unionin jäsenille.
Tämä tarkoittaa, että kaikki unionin jäsenet jakavat saman muistiosoitteen, ja **unionin koko on yhtä suuri kuin sen suurimman jäsenen koko**.

Unionin pääasiallinen käyttötarkoitus on erilaisten tietotyyppien asettaminen saman muistialueen päälle, eli yhden muistialueen esittäminen eri tietotyyppeinä.

Koska unionissa kentät sijaitsevat samassa muistisolussa, voimme käsitellä samaa dataa eri tavoilla:


I2luY2x1ZGUgPHN0ZGlvLmg+CgovLyBkZWNsYXJpbmcgYSB1bmlvbiAKdW5pb24gRGF0YSB7CiAgICBpbnQgYTsKICAgIGNoYXIgYjsKfSBkYXRhOwoKaW50IG1haW4oKSB7CiAgICBkYXRhLmEgPSA3NzsgLy8gYXNzaWduaW5nIGEgdmFsdWUgdG8gdmFyaWFibGUgYQoKICAgIHByaW50ZigiVmFsdWUgb2YgZGF0YS5hOiAlZFxuIiwgZGF0YS5hKTsKICAgIHByaW50ZigiVmFsdWUgb2YgZGF0YS5iOiAlY1xuIiwgZGF0YS5iKTsKCiAgICByZXR1cm4gMDsKfQ==

Esimerkissä muuttujat `data.a` ja `data.b` jakavat saman muistin. Annoimme arvon 77 kentälle `a`, mutta voimme tulkita samat tavut merkkinä kentässä `b`.

### Kohdistus unioneissa

Kuten rakenteissa, myös unioneissa käytetään **kohdistusta ja täytebittiä**. Kääntäjä voi lisätä ylimääräisiä tavuja, jotta jokainen jäsen alkaa oikeasta muistirajasta.

I2luY2x1ZGUgPHN0ZGlvLmg+Cgp1bmlvbiBEYXRhIHsKICAgIGludCBhOyAvLyA0IGJ5dGVzCiAgICBkb3VibGUgYjsgLy8gOCBieXRlcwogICAgY2hhciBjWzIwXTsgLy8gMjAgYnl0ZXMKfTsKCmludCBtYWluKCkgewogICAgcHJpbnRmKCJTaXplIG9mIHVuaW9uIERhdGE6ICV6dSBieXRlc1xuIiwgc2l6ZW9mKHVuaW9uIERhdGEpKTsKCiAgICByZXR1cm4gMDsKfQ==

Unioni voi tallentaa vain yhden arvon kerrallaan, ja sen koko on yhtä suuri kuin sen **suurimman jäsenen** koko. Esimerkissä, jossa on `int a` (4 tavua), `double b` (8 tavua) ja `char c[20]`, unionin vähimmäiskoko on 20 tavua. Kääntäjä voi kuitenkin lisätä ylimääräisiä tavuja **kohdistusta** varten, jotta `double` tai `int` alkavat oikeasta muistirajasta. Tämän seurauksena `sizeof(union Data)` voi olla suurempi kuin 20, esimerkiksi 24 tavua.


#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

Hanki vankka ymmärrys siitä, miten rakenteet toimivat C:ssä, perusmääritelmistä edistyneisiin muistikonsepteihin. Tutustu osoittimien vuorovaikutukseen jäsennellyn datan kanssa, löydä tehokkaita tapoja järjestää tietoa ja vahvista osaamistasi toteuttamalla oikeita tietorakenteita, kuten linkitettyjä listoja.

Tutustu rakenteiden perusteisiin, ymmärrä niiden käyttötarkoitus ja vahvista osaamistasi rakenteisen datan määrittelyssä, luomisessa ja käsittelyssä.

Opi, miten pointterit ovat vuorovaikutuksessa rakenteiden kanssa, ymmärrä miksi tämä yhteys on tärkeä, ja hallitse keskeiset tekniikat kuten dynaaminen varaaminen ja rakenteiden välittäminen funktioille.

Hanki vankka ymmärrys siitä, miten rakenteet tallennetaan muistiin, tutustu kohdistukseen ja täytebittien käyttöön sekä opi, miten unionit auttavat hallitsemaan jaettua dataa tehokkaasti.

Syvenny edistyneisiin struct-malleihin, mukaan lukien sisäkkäiset ja anonyymit structit, tutustu käytännöllisiin tapoihin yhdistää niitä taulukoihin ja perehdy yleisiin tietorakenteisiin.

Rakenna varmuutta toteuttamalla linkitetty lista alusta alkaen, tutki sen rakennetta ja luo olennaiset funktiot alkioiden lisäämiseen, läpikäyntiin ja hallintaan.

Unionit

Kohdistus unioneissa

Esimerkki

Ratkaisu