union关键字 在16进制数与其他数据类型互相转换时的应用

//
// Created by HP on 2025/2/10.
//

#ifndef SSUDRIVER_BYTESTRUCT_H
#define SSUDRIVER_BYTESTRUCT_H

#include <iostream>
#include <bitset>
#include <vector>

/* 字节序类型 */
enum class ByteOrder {
    LittleEndian,       /* 低前高后 */
    BigEndian,          /* 高前低后 */
};

/* 工具函数 用于拼接bitset使用 */

// 基本情况：没有更多的 bitset 需要拼接
template<typename... Args>
std::bitset<8 * sizeof...(Args)> concatenateBitsets() {
    return std::bitset<8 * sizeof...(Args)>();
}

// 递归情况：拼接当前 bitset 和剩余的 bitset
template<typename First, typename... Args>
std::bitset<8 * (1 + sizeof...(Args))> concatenateBitsets(First first, Args... args) {
    std::string result = first.to_string();

    std::bitset<8 * sizeof...(Args)> rest = concatenateBitsets(args...);
    result += rest.to_string();

    return std::bitset<8 * (1 + sizeof...(Args))>(result);
}

//// 辅助函数，将 vector 中的 bitset 展开并传递给 concatenateBitsets
//template<typename T, size_t... Is>
//std::bitset<8 * sizeof...(Is)> concatenateVectorBitsetsImpl(const std::vector<T> &vec, std::index_sequence<Is...>) {
//    return concatenateBitsets(vec[Is]...);
//}

//template<typename T>
//std::bitset<8 * typename std::vector<T>::size_type> concatenateVectorBitsets(const std::vector<T> &vec) {
//    return concatenateVectorBitsetsImpl(vec, std::make_index_sequence<vec.size()>{});
//}
//// 主函数模板，调用辅助函数
//template<typename T>
//std::bitset<8 * typename std::vector<T>::size_type>
//concatenateVectorBitsets(const std::vector<T>& vec) {
//    // 使用索引序列调用实现函数
//    return concatenateVectorBitsetsImpl(vec, std::make_index_sequence<vec.size()>{});
//}

class OneByteStruct {

public:

    explicit OneByteStruct(uint8_t input) {

        value_uint8_t = input;
        byte = std::bitset<8l>{input};
    }

    explicit OneByteStruct(int8_t input) {

        value_int8_t = input;
        byte = std::bitset<8l>{static_cast<unsigned long long>(input)};
    }

    explicit OneByteStruct(char input) {

        value_char = input;
        byte = std::bitset<8l>{static_cast<unsigned long long>(input)};
    }

    /* 解析成无符号数据 */
    uint64_t getUSignedValue() {
        return byte.to_ullong();
    }

    /* 解析成有符号数据 */
    int64_t getSignedValue() {
        return byte.to_ullong();
    }

    /* 返回某一位状态 */
    bool getBitStatus(uint64_t index) {
        return byte[index];
    }

private:
    std::bitset<8> byte;

    /* 便于各种数据类型基于内存进行转换 */
    union {
        int8_t value_int8_t;
        uint8_t value_uint8_t;
        char value_char{};
    };

};

class TwoByteStruct {

public:

    /* 传入单个长度数据 需要区分大端和小端 */
    explicit TwoByteStruct(uint16_t input, ByteOrder inputByteOrder = ByteOrder::LittleEndian) {

        uint8_t lowByte = static_cast<uint8_t>(input & 0xFF);
        uint8_t highByte = static_cast<uint8_t>((input >> 8) & 0xFF);


        if (inputByteOrder == ByteOrder::LittleEndian) {

            value_uint16_t = input;
            byte.emplace_back(std::bitset<8l>{lowByte});
            byte.emplace_back(std::bitset<8l>{highByte});

        } else {

            value_uint16_t = ((lowByte) << 8) | highByte;
            byte.emplace_back(std::bitset<8l>{highByte});
            byte.emplace_back(std::bitset<8l>{lowByte});

        }
    }

    explicit TwoByteStruct(int16_t input, ByteOrder inputByteOrder = ByteOrder::LittleEndian) {

        uint8_t lowByte = static_cast<uint8_t>(input & 0xFF);
        uint8_t highByte = static_cast<uint8_t>((input >> 8) & 0xFF);


        if (inputByteOrder == ByteOrder::LittleEndian) {

            value_int16_t = input;
            byte.emplace_back(std::bitset<8l>{lowByte});
            byte.emplace_back(std::bitset<8l>{highByte});

        } else {

            value_int16_t = ((lowByte) << 8) | highByte;
            byte.emplace_back(highByte);
            byte.emplace_back(lowByte);

        }
    }


    /* inputLow 低八位 inputHigh 高八位 */
    explicit TwoByteStruct(uint8_t inputLow, uint8_t inputHigh) {

        byte.emplace_back(inputLow);
        byte.emplace_back(inputHigh);
    }

    explicit TwoByteStruct(int8_t inputLow, int8_t inputHigh) {

        byte.emplace_back(static_cast<unsigned long long>(inputLow));
        byte.emplace_back(static_cast<unsigned long long>(inputHigh));
    }

    /* 解析成无符号数据 */
    uint64_t getUSignedValue() {
        return concatenateBitsets(byte[0], byte[1]).to_ullong();
    }

    /* 解析成有符号数据 */
    int64_t getSignedValue() {
        return concatenateBitsets(byte[0], byte[1]).to_ullong();
    }

    /* 返回某一位状态 */
    /* byteIndex: 字节位
     * index: bit位
     * 第几字节的bit位
     * */
    bool getBitStatus(size_t byteIndex, uint64_t index) {
        return byte[byteIndex][index];
    }


private:

    std::vector<std::bitset<8l>> byte{2l};

    /* 便于各种数据类型基于内存进行转换 */
    union {
        int16_t value_int16_t;
        uint16_t value_uint16_t;
        char value_char[2]{};
    };
};


#endif //SSUDRIVER_BYTESTRUCT_H