#include <iostream>
#include <cstdint>

struct SensorStruct
{
    float    measurement; // байти 0-3
    uint32_t statusFlags; // байти 4-7
};

union SensorUnion
{
    float    measurement; // байти 0-3
    uint32_t statusFlags; // байти 0-3 (ті самі!)
};

int main()
{
    std::cout << "sizeof(SensorStruct) = " << sizeof(SensorStruct) << "\n"; // 8
    std::cout << "sizeof(SensorUnion)  = " << sizeof(SensorUnion)  << "\n"; // 4

    SensorUnion packet;
    packet.measurement = 293.15f; // записуємо float

    // ЗАРАЗ активний член — measurement
    std::cout << "Temperature: " << packet.measurement << " K\n";

    packet.statusFlags = 0b00000011; // перезаписуємо ту саму пам'ять як uint32_t
    // ЗАРАЗ активний член — statusFlags (measurement "зіпсований")
    std::cout << "Status: " << packet.statusFlags << "\n";

    return 0;
}

#include <iostream>
#include <cstdint>

union AlignTest
{
    uint8_t  byte;    // 1 байт, вирівнювання 1
    uint16_t word;    // 2 байти, вирівнювання 2
    uint32_t dword;   // 4 байти, вирівнювання 4
    uint64_t qword;   // 8 байт, вирівнювання 8
};

union SmallOrBig
{
    char  c;   // 1 байт
    double d;  // 8 байт
};

int main()
{
    // Розмір = розмір найбільшого члена
    std::cout << "sizeof(AlignTest)  = " << sizeof(AlignTest)  << "\n"; // 8
    std::cout << "sizeof(SmallOrBig) = " << sizeof(SmallOrBig) << "\n"; // 8

    // Всі члени починаються з одної адреси
    AlignTest u;
    std::cout << "Адреса &u.byte:  " << static_cast<void*>(&u.byte)  << "\n";
    std::cout << "Адреса &u.word:  " << static_cast<void*>(&u.word)  << "\n";
    std::cout << "Адреса &u.dword: " << static_cast<void*>(&u.dword) << "\n";
    std::cout << "Адреса &u.qword: " << static_cast<void*>(&u.qword) << "\n";
    // Всі чотири адреси однакові!

    return 0;
}

#include <iostream>
#include <cstdint>
#include <iomanip>

union IntBytes
{
    uint32_t value;    // ціле число — 4 байти
    uint8_t  bytes[4]; // ті самі 4 байти як масив
};

int main()
{
    IntBytes u;
    u.value = 0x0A0B0C0D; // hex-значення для наочності

    std::cout << std::hex << std::setfill('0');
    std::cout << "value  = 0x" << std::setw(8) << u.value << "\n";

    // Читаємо ті самі байти через масив
    // На little-endian машині (x86): молодший байт — bytes[0]
    for (int i = 0; i < 4; ++i)
        std::cout << "bytes[" << i << "] = 0x" << std::setw(2)
                  << static_cast<int>(u.bytes[i]) << "\n";

    return 0;
}

#include <iostream>
#include <cstdint>

union IPv4
{
    uint32_t address;    // вся адреса як 32-бітне число (big-endian)
    uint8_t  octets[4]; // ті самі 4 байти як окремі октети
};

// Допоміжна функція для виведення адреси у форматі X.X.X.X
void printIPv4(const IPv4& ip)
{
    // Порядок октетів залежить від endianness.
    // На little-endian (x86) найстарший октет — octets[3].
    std::cout << static_cast<int>(ip.octets[3]) << "."
              << static_cast<int>(ip.octets[2]) << "."
              << static_cast<int>(ip.octets[1]) << "."
              << static_cast<int>(ip.octets[0]) << "\n";
}

int main()
{
    IPv4 ip;
    // Задаємо адресу 192.168.1.100 як 32-бітне число
    // 192 = 0xC0, 168 = 0xA8, 1 = 0x01, 100 = 0x64
    ip.address = 0xC0A80164; // big-endian представлення

    std::cout << "address (hex): 0x" << std::hex << ip.address << "\n";
    std::cout << "IPv4 string:   ";
    printIPv4(ip);

    // Задаємо через октети
    ip.octets[3] = 10;  // 10.
    ip.octets[2] = 0;   //  0.
    ip.octets[1] = 0;   //  0.
    ip.octets[0] = 1;   //  1

    std::cout << "New address:   ";
    printIPv4(ip);

    return 0;
}

#include <iostream>
#include <cstdint>
#include <iomanip>
#include <bitset>

union FloatBits
{
    float    f;
    uint32_t bits;
};

void printFloatBits(float value)
{
    FloatBits fb;
    fb.f = value;

    // Розкладаємо 32 біти за IEEE 754
    uint32_t sign     = (fb.bits >> 31) & 0x1;
    uint32_t exponent = (fb.bits >> 23) & 0xFF;
    uint32_t mantissa =  fb.bits        & 0x7FFFFF;

    std::cout << "float " << value << ":\n";
    std::cout << "  bits:     " << std::bitset<32>(fb.bits) << "\n";
    std::cout << "  sign:     " << sign << "\n";
    std::cout << "  exponent: " << exponent << " (bias=" << (int(exponent) - 127) << ")\n";
    std::cout << "  mantissa: " << std::hex << mantissa << std::dec << "\n";
}

int main()
{
    printFloatBits(1.0f);
    std::cout << "\n";
    printFloatBits(-3.14f);
    return 0;
}

#include <iostream>
#include <string>
#include <cstdint>

// Повідомлення системи подій — може нести або ціле число, або дійсне
struct Event
{
    enum class Type { Integer, Float };

    Type type; // який член активний

    union // анонімний union — члени доступні без імені
    {
        int32_t intValue;
        float   floatValue;
    };
};

void printEvent(const Event& e)
{
    switch (e.type)
    {
        case Event::Type::Integer:
            std::cout << "Event(int):   " << e.intValue   << "\n";
            break;
        case Event::Type::Float:
            std::cout << "Event(float): " << e.floatValue << "\n";
            break;
    }
}

int main()
{
    Event e1;
    e1.type     = Event::Type::Integer;
    e1.intValue = 42; // доступ без імені union — одразу через структуру

    Event e2;
    e2.type       = Event::Type::Float;
    e2.floatValue = 3.14f;

    printEvent(e1);
    printEvent(e2);

    return 0;
}

#include <iostream>

union Data
{
    int   i;
    float f;
};

int main()
{
    Data d;
    d.i = 42;              // записали int → i є активним членом

    // Законно: читаємо активний член
    std::cout << d.i << "\n"; // 42

    // UNDEFINED BEHAVIOR: читаємо f, але активний член — i
    // Компілятор може зробити що завгодно: вивести сміття,
    // оптимізувати до нуля або спричинити інший непередбачуваний ефект
    std::cout << d.f << "\n"; // UB!

    d.f = 1.5f;            // записали float → тепер f є активним членом
    // Тепер законно читати f, але i вже не активний
    std::cout << d.f << "\n"; // 1.5 — OK
    std::cout << d.i << "\n"; // UB!

    return 0;
}

#include <iostream>
#include <string>
#include <new> // для placement new

union StringOrInt
{
    std::string s; // нетривіальний тип — має конструктор/деструктор
    int         i;

    // Компілятор видаляє конструктор і деструктор union за замовчуванням
    StringOrInt() {} // порожній конструктор — не конструює жодного члена
    ~StringOrInt() {} // порожній деструктор — не руйнує жодного члена
};

int main()
{
    StringOrInt u;

    // Ручне конструювання рядка через placement new
    new (&u.s) std::string("Hello, union!");
    std::cout << u.s << "\n"; // Hello, union!

    // Ручне руйнування рядка перед перемиканням на int
    u.s.~basic_string();

    // Тепер активний член — int
    u.i = 99;
    std::cout << u.i << "\n"; // 99

    return 0;
}

#include <iostream>
#include <variant>
#include <string>

int main()
{
    // Variant може зберігати int, float або std::string
    std::variant<int, float, std::string> v;

    v = 42;
    std::cout << "int:    " << std::get<int>(v) << "\n";

    v = 3.14f;
    std::cout << "float:  " << std::get<float>(v) << "\n";

    v = std::string("Hello, variant!");
    std::cout << "string: " << std::get<std::string>(v) << "\n";

    // Запит поточного типу
    std::cout << "index:  " << v.index() << "\n"; // 2 (третій тип у списку)

    // Безпечна перевірка типу
    if (std::holds_alternative<std::string>(v))
        std::cout << "Зараз зберігається std::string\n";

    return 0;
}

#include <iostream>
#include <variant>
#include <stdexcept>

int main()
{
    std::variant<int, float> v = 42;

    // std::get<T> кидає std::bad_variant_access, якщо тип неактивний
    try
    {
        std::cout << std::get<int>(v)   << "\n"; // OK: 42
        std::cout << std::get<float>(v) << "\n"; // кидає виключення!
    }
    catch (const std::bad_variant_access& e)
    {
        std::cout << "Помилка: " << e.what() << "\n";
    }

    // std::get_if — безпечний варіант, повертає вказівник або nullptr
    if (auto* ptr = std::get_if<int>(&v))
        std::cout << "int: " << *ptr << "\n";
    else
        std::cout << "Не int\n";

    return 0;
}

#include <iostream>
#include <variant>
#include <string>
#include <vector>

// Тип для повідомлень протоколу
using Message = std::variant<int, float, std::string>;

void processMessage(const Message& msg)
{
    std::visit([](const auto& value)
    {
        using T = std::decay_t<decltype(value)>;

        if constexpr (std::is_same_v<T, int>)
            std::cout << "Ціле: " << value << "\n";
        else if constexpr (std::is_same_v<T, float>)
            std::cout << "Дійсне: " << value << "\n";
        else if constexpr (std::is_same_v<T, std::string>)
            std::cout << "Рядок: \"" << value << "\"\n";
    }, msg);
}

int main()
{
    std::vector<Message> messages = {
        42,
        3.14f,
        std::string("Привіт!"),
        100,
        2.71828f
    };

    for (const auto& m : messages)
        processMessage(m);

    return 0;
}