C++实战之二进制数据处理与封装

// 先清0其他位，再判断是否等于0b100
bool isOne = (byte & 0b100) == 0b100;

// 获得flag要截取byte7前3位数据：先清空后5位，保留前3位数据，再右移5位将前3位数据移到起始
uint8_t flag = (byte7 & 0b11100000) >> 5;
// 此处以大端存储，获得offset要截取byte7的低5位作为高位，byte8作为低位，求和：先清空byte7前3位，保留后5位数据，把它移到高8位上，再通过全0的低8位与byte8按位求或来求二者之和
((byte7 & 0b00011111) << 8) | byte8;

// true为大端，低位地址存高位字节
bool ENDIAN = true;
 
/**
 * 将data转换为无符号整形数字（无符号char，short，int，long，long long等）
 * @tparam T 目标类型，默认为 uint32_t
 * @param data 载荷数据 byte数组
 * @param valueSize 数据长度，单位：byte，-1表示根据T类型自动计算
 * @param default_value 默认值，默认为0
 * @return 根据data转换的无符号整形数据
 */
template<typename T = uint32_t>
T payloadToUnsignedInt(std::vector<uint8_t> data, int valueSize = -1, T default_value = uint32_t(0)) {
    if (valueSize == -1) valueSize = sizeof(T);
    if (valueSize > data.size()) return default_value;
    T value = 0;
    for (int i = 0; i < valueSize; i++) {
        if (ENDIAN) {
            value |= (data[i] & 0xff) << ((valueSize - 1 - i) << 3);
        } else {
            value |= (data[i] & 0xff) << (i << 3);
        }
    }
    return value;
}
 
/**
 * 无符号整形转换为载荷 byte数组
 * @param value 无符号整形数据
 * @param valueSize 数据长度，单位：byte，-1表示根据T类型自动计算
 * @return 载荷 byte数组
 */
template<typename T>
std::vector<uint8_t> uintToPayload(T value, int valueSize = -1) {
    if (valueSize == -1) valueSize = sizeof(T);
    std::vector<uint8_t> data(valueSize, 0);
    for (int i = 0; i < valueSize; i++) {
        if (ENDIAN) {
            data[i] = (value >> ((valueSize - 1 - i) << 3)) & 0xff;
        } else {
            data[i] = (value >> (i << 3)) & 0xff;
        }
    }
    return data;
}

/**
 * 载荷配置项
 */
const CmdManager cmd_manager = { 2, {  // 指令个数，下面是每一个指令的配置
        {"TCRQ", 3, {  // 配置项名，配置项对应的字段数
            {"TE_SEQ_NO", -1, &FT_SHORT, 0},  // 具体配置项内字段配置（字段名，字段偏移，字段类型，配置项该字段过滤条件
            {"CMD", -1, &FT_CHARS_4, "TCRQ"},  // 配置项要求该字段等于"TCRQ"，数据不满足则不匹配该配置项
            {"REPEAT_COUNT", -1, &FT_SHORT, 0}}}
}};

/**
 * 数据抽象类，提供二进制流到对象的相互转化能力
 * 内部类，只复用代码，不用于多态
 * @tparam size 数据字节长度
 */
template<int size>
class DataType {
public:
    DataType() { resetData(); }
    // 初始化所有数据
    void resetData() const { memset((void *) (this), 0, size); }
    // 从二进制流加载数据
    bool loadData(const std::vector<uint8_t>& data, int startIndex=0) {
        auto * p = (uint8_t *) this;  // 将自身当作二进制数组处理
        for (int i = 0; i < size; i++) {
            *p = data[i + startIndex];
            p++;
        }
        return true;
    }
    // 基于自身生成新的二进制数据流
    [[nodiscard]] std::vector<uint8_t> createData() const {
        std::vector<uint8_t> result;
        auto p = (uint8_t const *) this;
        for (int i = 0; i < size; i++) {
            result.push_back(*p);
            p++;
        }
        return result;
    }
    [[nodiscard]] int getSize() const { return size; }
};
 
// 以顺序声明方式定义具体的二进制数据类型，支持嵌套声明
class MACHeader : public DataType<14> {
public:
    // 通过上述无符号整形与字节流相互转化的方法将netType的读写进行封装
    [[nodiscard]] uint16_t getNetType() const {
        return payloadToUnsignedInt(std::vector<uint8_t>(netType.begin(), netType.end()), 2, uint16_t(0));
    }
    void setNetType(uint16_t _netType) {
        auto data = uintToPayload(_netType, 2);
        std::copy(data.begin(), data.end(), netType.begin());
    }
 
    // 提供与json互转的能力，为了提供映射为python对象的能力
    bool loadJson(const Json::Value& json);
    [[nodiscard]] Json::Value createJson() const;
 
    std::array<uint8_t, 6> desMac;  // 占多个字节的数据采用std::array数组描述，可避免类型丢失，同时保证数据类型仍然一致对其
    std::array<uint8_t, 6> srcMac;
    std::array<uint8_t, 2> netType;
};