如何在C++中将两个4位有符号整数压缩为8位整数并正确还原？

问题根源 #

你的压缩和解压代码存在两处核心问题：

1. 压缩阶段的运算符优先级错误，导致符号位与LSB的组合逻辑冗余且易出错；
2. 解压阶段的类型转换与移位逻辑依赖编译器的算术右移实现，兼容性差，且未正确处理4位补码到8位的符号扩展。

优化后的压缩实现 #

直接利用[-8,7]范围内整数的低4位恰好是4位补码的特性，无需拆分符号位和LSB，代码更简洁可靠：

#include <iostream>
#include <cstdint>
#include <fstream>
#include <vector>

// 压缩两个int8_t到一个uint8_t
uint8_t compact_pair(int8_t a, int8_t b) {
    // 取每个数的低4位，左移第一个数的低4位到高4位，再与第二个数的低4位合并
    return ((static_cast<uint8_t>(a) & 0x0F) << 4) | (static_cast<uint8_t>(b) & 0x0F);
}

// 批量压缩数组
std::vector<uint8_t> compact_array(const std::vector<int8_t>& arr) {
    std::vector<uint8_t> compacted;
    compacted.reserve((arr.size() + 1) / 2); // 向上取整分配空间

    for (size_t i = 0; i < arr.size(); i += 2) {
        int8_t a = arr[i];
        // 如果数组长度为奇数，最后一个元素补0（或根据需求调整补位值）
        int8_t b = (i + 1 < arr.size()) ? arr[i + 1] : 0;
        compacted.push_back(compact_pair(a, b));
    }
    return compacted;
}

优化后的解压实现 #

通过判断4位补码的最高位（值≥8时为负数），手动完成符号扩展，避免依赖编译器行为：

// 从uint8_t解压出两个int8_t
void decompact_pair(uint8_t compact, int8_t& a, int8_t& b) {
    // 提取高4位并符号扩展
    uint8_t high = (compact >> 4) & 0x0F;
    a = (high >= 8) ? static_cast<int8_t>(high | 0xF0) : static_cast<int8_t>(high);

    // 提取低4位并符号扩展
    uint8_t low = compact & 0x0F;
    b = (low >= 8) ? static_cast<int8_t>(low | 0xF0) : static_cast<int8_t>(low);
}

// 批量解压数组
std::vector<int8_t> decompact_array(const std::vector<uint8_t>& compacted, size_t original_size) {
    std::vector<int8_t> arr;
    arr.reserve(original_size);

    for (size_t i = 0; i < compacted.size(); ++i) {
        int8_t a, b;
        decompact_pair(compacted[i], a, b);
        arr.push_back(a);
        // 如果原始数组长度为奇数，最后一个压缩元素的第二个值丢弃
        if (arr.size() < original_size) {
            arr.push_back(b);
        }
    }
    return arr;
}

测试示例 #

int main() {
    std::vector<int8_t> original = {-1, 1, -8, 7, 0};
    auto compacted = compact_array(original);

    // 写入二进制文件
    std::ofstream out("data.bin", std::ios::binary);
    out.write(reinterpret_cast<const char*>(compacted.data()), compacted.size());
    out.close();

    // 读取二进制文件并解压
    std::vector<uint8_t> read_compacted(compacted.size());
    std::ifstream in("data.bin", std::ios::binary);
    in.read(reinterpret_cast<char*>(read_compacted.data()), read_compacted.size());
    in.close();

    auto decompacted = decompact_array(read_compacted, original.size());

    // 验证结果
    for (size_t i = 0; i < original.size(); ++i) {
        std::cout << "Original: " << static_cast<int>(original[i]) 
                  << ", Decompressed: " << static_cast<int>(decompacted[i]) << "\n";
    }

    return 0;
}

关键说明 #

• 压缩时直接取低4位：[-8,7]的int8_t值，其低4位正好对应4位补码，无需额外处理符号位；
• 解压时手动符号扩展：当4位值≥8时，说明是负数，将高4位设为1（| 0xF0），确保转换为int8_t后是正确的负数；
• 批量处理时考虑数组长度奇偶性：奇数长度时最后一个元素补0压缩，解压时丢弃多余的补位值。

内容的提问来源于stack exchange，提问作者nasy